Uma interrupção fatal é um erro em tempo de compilação que para a compilação antes de qualquer saída ser produzida. Cada interrupção nomeia o ficheiro, a entidade e o campo em causa, explica o que o compilador não conseguiu resolver e indica a alteração concreta de autoria que a corrige. O compilador nunca repara nem reescreve silenciosamente a entrada — se algo estiver errado, a compilação para e indica onde.
Este catálogo está organizado pela fase da compilação em que cada interrupção ocorre.
Cada entrada abaixo cita a mensagem que uma compilação imprime para a condição que documenta: a frase fixa que enuncia a condição e, depois, o que essa ocorrência forneceu. Num terminal, essa mensagem surge dentro de uma moldura — um cabeçalho entre parênteses retos com a categoria e o código curto da condição, um ponteiro para o ficheiro e a chave em causa seguido da instância a que a falha diz respeito, como (instance <name>) — ou apenas essa instância, como instance <name>, quando nenhum ficheiro se aplica — e a mensagem na linha de baixo — pelo que uma linha inteira colada de uma compilação não corresponderá a uma entrada desta página, ao passo que a mensagem que contém corresponderá; error-translation.md expõe a moldura por completo.
Quem chega de uma compilação com um código curto na mão — a letra E e quatro algarismos, no cabeçalho entre parênteses retos do diagnóstico — deve começar por Encontrar uma interrupção a partir do código curto que a compilação imprimiu no fim desta página, que lista cada condição aqui catalogada junto ao código curto que uma compilação imprime para ela.
Ao carregar os ficheiros
O compilador lê cada Aggregate, Manifest, Component, Feature, Recipe, FeatureRecipe, Plugin e Release referenciado pela compilação, valida cada um face ao seu esquema e interpola os parâmetros tipados da Release no Aggregate.
YAML anchor aliased inside its own content (Âncora YAML referenciada por um alias dentro do seu próprio conteúdo)
Um documento ancora um nó com &name e depois referencia-o por alias com *name algures dentro do conteúdo que essa âncora abrange. Expandir o alias reproduz a âncora, cujo conteúdo volta a conter o alias, pelo que o documento descreve uma estrutura sem fim. Não há nada de finito para ler, muito menos para validar, e a compilação para em vez de iniciar um percurso que não pode terminar.
Ler YAML para uma árvore não expande os aliases, pelo que um documento com esta forma é lido sem queixas e só falha quando algo o percorre. A recusa situa-se, portanto, entre a leitura e o percurso — e uma compilação lê o YAML escrito pelo autor em mais do que um ponto, pelo que a mesma condição pode ser encontrada em mais do que um. Quatro pontos comunicam-na, cada um enquadrando a mesma explicação com o que localiza o documento nessa superfície:
Um ficheiro de entidade, quando é lido. A compilação para antes de essa entidade ser verificada face ao seu esquema, pelo que esta interrupção nomeia uma âncora em vez de um campo e não indica linha nem coluna: nesse ponto, o documento não tem nenhuma posição para a qual um diagnóstico possa apontar de forma útil.
Um corpo de esquema, quando é compilado. Um pilar spec.schema: é compilado da forma compacta para um documento JSON Schema depois de o seu ficheiro ter sido lido, pelo que esta interrupção ocorre durante essa compilação e não antes dela, e indica de facto uma linha. A forma que uma leitura anterior não consegue detetar é um corpo de escape $jsonschema:: um corpo de escape é um escalar de bloco — texto simples, sem âncoras — enquanto o ficheiro que o rodeia é lido, e as suas âncoras só se tornam âncoras quando esse texto é, por sua vez, analisado, um nível abaixo. Quando o ciclo estava dentro de um bloco desses, a interrupção nomeia também $jsonschema como a palavra-chave cujo corpo o continha.
O esquema de workload de um Plugin fornecedor, quando o Plugin é carregado.spec.provider.workloadSchema escreve-se como um escalar de bloco: texto simples enquanto o próprio ficheiro do Plugin é lido, sem âncoras nesse momento, e as suas âncoras só se tornam âncoras quando esse texto é analisado como um documento próprio, um nível abaixo. Essa análise e a compilação que se lhe segue ocorrem ambas quando o Plugin é carregado, pelo que esta interrupção ocorre aí e não quando o ficheiro é lido, e indica uma linha. Quando o ciclo estava dentro de um escape $jsonschema: no corpo do esquema, a interrupção nomeia também $jsonschema como a palavra-chave cujo corpo o continha. Ver ../entities/plugin.md para a superfície de autoria do campo.
Um fragmento CloudFormation renderizado, quando o fornecedor o lê. Uma Recipe cloudformation cria um fragmento, e um corpo artifacts: é um modelo — pelo que aquilo que o fornecedor lê é o texto em que esse modelo foi renderizado, conteúdo que não existia enquanto os ficheiros estavam a ser lidos. Esta interrupção ocorre, portanto, enquanto a saída está a ser renderizada, depois de todas as verificações de esquema já terem sido aprovadas. Ver ../providers/cloudformation.md para a superfície de autoria dos fragmentos.
A recusa incide sobre a recursão, nunca sobre a reutilização nem sobre a profundidade. Ancorar conteúdo partilhado e referenciá-lo a partir de muitos locais é um padrão de autoria suportado — ver ../entities/aggregate.md «Padrões de âncoras YAML (bloco defs:)» e ../entities/manifest.md «Âncoras YAML para manifestos DRY» — e uma referência que se expande e termina carrega normalmente, independentemente de quantas vezes apareça e da profundidade de aninhamento do documento; a profundidade, por si só, nunca é motivo para esta interrupção. O que interrompe a compilação é uma âncora alcançada enquanto a compilação ainda está dentro dela, incluindo quando é alcançada indiretamente, através de uma segunda âncora declarada abaixo dela. A mensagem nomeia a âncora sobre a qual o ciclo se fecha, que não é necessariamente a âncora mais externa do documento.
Mensagens emitidas. Todas as quatro contêm a mesma explicação, e isso é deliberado: trata-se de uma única condição encontrada em quatro pontos, e um autor que aprendeu a lê-la uma vez não deveria ter de a aprender de novo. Só a moldura que localiza o documento difere.
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 (a âncora é referenciada por um alias dentro do seu próprio conteúdo, pelo que o documento se expande sem fim; aponte esse alias para conteúdo declarado fora da âncora, ou escreva o conteúdo por extenso)
Um ficheiro de entidade é enquadrado pela verificação de envelope que o estava a ler e pelo caminho a partir do qual foi lido:
document envelope validation failed: envelope: parse <path>: <the explanation above> (falha na validação do envelope do documento: envelope: análise)
Um corpo de esquema é enquadrado pela sua posição dentro do esquema e, quando o ciclo estava dentro de um bloco $jsonschema:, pela palavra-chave de escape. A compilação comunica-o sob uma etiqueta CATALOG_ERROR, que nomeia também o ficheiro, a entidade e o pilar cujo corpo não foi possível compilar:
compactform at <schema-path>:<line> (keyword "$jsonschema"): <the explanation above> (compactform na posição, palavra-chave)
O esquema de workload de um Plugin fornecedor tem essa mesma moldura de forma compacta; o que difere é a etiqueta CATALOG_ERROR à sua volta, que nomeia o Plugin e spec.provider.workloadSchema em vez da entidade e do seu pilar.
Um fragmento renderizado é enquadrado pelo fornecedor que o leu:
cloudformation-provider: parse fragment: <the explanation above> (cloudformation-provider: análise do fragmento)
Como corrigir: apontar o alias para conteúdo declarado fora da âncora dentro da qual se encontra atualmente, ou escrever por extenso o conteúdo repetido no ponto de utilização. Num Aggregate ou num Manifest, o bloco defs: de nível raiz é o local natural para âncoras partilhadas — fica fora de todos os blocos que o referenciam, pelo que uma âncora aí declarada não pode ser alcançada a partir de dentro de si própria. Nos outros tipos de entidade, que não têm bloco defs:, deve ancorar-se o conteúdo partilhado num local do qual o bloco que o referencia não seja descendente. Uma âncora pode ser referenciada a partir de qualquer número de locais e de qualquer profundidade; a única forma que não pode assumir é a de uma referência que volta a cair dentro do conteúdo que a âncora abrange.
O mesmo remédio aplica-se onde quer que a interrupção tenha sido encontrada, e a moldura indica que documento abrir: o próprio ficheiro de entidade, o bloco $jsonschema: dentro de um pilar de esquema, o corpo workloadSchema dentro de um Plugin fornecedor, ou o corpo artifacts: cuja saída renderizada o fornecedor leu. Neste último caso, a âncora está no modelo que o autor escreveu, não no texto renderizado — a renderização reproduziu-a fielmente.
Parameter type mismatch / contract violation (Tipo de parâmetro incompatível / violação de contrato)
A Release forneceu um valor cujo tipo ou forma não corresponde ao que o Aggregate declarou para esse parâmetro. O validador de contratos de parâmetros deteta incompatibilidades de tipo, violações de enum, violações de intervalo, violações de padrão, cadeias de caracteres que não são instâncias válidas do format declarado, falhas de predicados validate: e parâmetros obrigatórios em falta, antes de ser executada qualquer interpolação de template. Os nomes que um format pode assumir, e o que cada um verifica, estão listados em Formatos com nome.
Mensagem emitida — a frase que enuncia a condição, depois a entidade com erro, o caminho do campo e o detalhe da restrição:
parameter contract violated (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" expected type <declared type>; got <received type>) (contrato de parâmetro violado: o parâmetro esperava o tipo declarado e recebeu outro)
Para um parâmetro declarado required: true sem default: e sem valor fornecido pela Release, o relatório contém uma condição diferente e um código curto diferente:
required parameter not supplied (Aggregate, at .spec.parameters.<parameter>, parameter "<parameter>" is required but not supplied by Release) (parâmetro obrigatório não fornecido: o parâmetro é obrigatório, mas a Release não o fornece)
Apenas o detalhe após o caminho do campo muda consoante a restrição não cumprida. A frase e o enquadramento entre parênteses à sua volta são sempre os mesmos, o que faz da frase a parte com que comparar e do detalhe a parte a ler. Os detalhes que um build imprime, um por tipo de restrição:
parameter "<parameter>" value <value> not in enum [<members>] (valor do parâmetro fora do enum) parameter "<parameter>" value "<value>" does not match pattern "<pattern>" (o valor do parâmetro não corresponde ao padrão) parameter "<parameter>" value "<value>" is not a valid <format>: <reason> (o valor do parâmetro não é válido para o formato) parameter "<parameter>" value <value> above max <max> (valor do parâmetro acima do máximo) parameter "<parameter>" failed validate predicate (o predicado validate do parâmetro falhou) parameter "<parameter>" validate predicate error: <detail> (erro no predicado validate do parâmetro)
O <reason> de uma falha de formato indica o que está errado no valor nos termos próprios desse formato. Um valor dentro de um contrato aninhado é identificado pelo seu caminho, pelo que um format declarado por um contrato items: é verificado em cada elemento e o relatório identifica aquele que falhou: o segundo elemento de um parâmetro hosts é reportado em .spec.parameters.hosts.1, e o seu detalhe indica "hosts.1".
Um parâmetro que declara um validateMessage: substitui todo esse detalhe pelo seu próprio texto, pelo que o relatório indica parameter contract violated (Aggregate, at .spec.parameters.<parameter>, <the validateMessage you wrote>) — o enquadramento mantém-se e a frase que escreveu fica onde estaria o detalhe da restrição.
A mesma condição abrange um contrato que, tal como está escrito, não consegue restringir nada. Um pattern: que não seja uma expressão regular válida é recusado quando o contrato de parâmetros do Aggregate é lido, antes de ser verificado qualquer valor da Release, pelo que interrompe o build quer uma Release forneça o parâmetro, quer não. O relatório aponta para a chave — .spec.parameters.<parameter>.pattern, ou o caminho através de um contrato aninhado como .spec.parameters.<parameter>.items.pattern — e o seu detalhe indica a declaração, o padrão e o motivo:
parameter "<parameter>" pattern "<pattern>" does not compile: <reason> (o padrão do parâmetro não compila)
Um format: que indique um formato fora do conjunto suportado também não consegue restringir nada, e é recusado no mesmo ponto, antes de ser verificado qualquer valor da Release, pelo que também interrompe o build quer uma Release forneça o parâmetro, quer não. Dentro de um contrato aninhado — em items:, properties: ou valuesType: — é esta condição que o recusa: o relatório aponta para a chave, como .spec.parameters.<parameter>.items.format, e o seu detalhe indica a declaração, o formato tal como foi escrito e todos os nomes suportados:
parameter "<parameter>.items": format "<format>" is not supported; the supported formats are email, uri, hostname, ipv4, ipv6, uuid, date-time, date (formato do parâmetro não suportado; os formatos suportados são email, uri, hostname, ipv4, ipv6, uuid, date-time, date)
Na própria declaração de um parâmetro, o mesmo nome é recusado um passo antes, pelo esquema do Aggregate, cujo format só admite os nomes suportados. Essa recusa é o documento a falhar o esquema do seu tipo — uma condição diferente, com o seu próprio código curto, E0215 — e aggrega pull e aggrega validate --release listam-na depois de reportarem a referência aggregate: da Release como impossível de resolver (E0170), uma vez que o Aggregate que contém o nome não foi carregado:
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 (falha na validação do envelope do documento: o formato não está entre os valores permitidos; o documento deve ser corrigido para corresponder ao esquema do seu tipo)
O detalhe de erro do predicado abrange as duas formas pelas quais um predicado validate: pode não produzir um veredicto: uma função que a superfície não regista e uma referência a algo que não seja .value. Cada uma é reportada em relação ao predicado e não ao valor, e cada uma indica o que não conseguiu resolver.
Um predicado validate: lê o valor em validação como .value, e esse é o único nome que define. Um predicado que indique qualquer outra coisa é recusado antes de ser executado, pelo que uma referência mal escrita é reportada como o erro de nomeação que é, em vez de se resolver em nada e surgir como um valor que falhou a validação.
Como corrigir: alterar o valor da Release para que cumpra as restrições type / enum / min / max / pattern / format declaradas para o parâmetro, fornecer um parâmetro obrigatório em falta, corrigir um pattern: que não compila, substituir um format: que indique um formato não suportado por um dos formatos com nome ou removê-lo, corrigir um predicado validate: que indique algo que não seja .value ou que produza algo que não seja true ou false, ou alargar a declaração do Aggregate para aceitar a forma de que realmente se precisa.
Regras de forma da Recipe
Uma Recipe compõe a sua saída a partir de três tipos de entrada — de origem, sintetizada e artefactos — descritos em ../../architecture/16-recipe-input-composition.md. A forma de uma Recipe válida é restringida pelas regras de composição abaixo. Diferem no momento em que são verificadas — quando a Recipe é carregada, quando um nó é renderizado ou quando a saída é emitida —, pelo que convém ler cada entrada para saber em que ponto a sua própria condição é verificada.
Cada regra tem o nome daquilo que restringe. Não há numeração, e nenhum número está reservado: um nome indica que parte da Recipe abrir, e continua a indicá-lo por mais que a lista abaixo cresça ou seja reordenada. Quando for necessário registar uma condição de forma duradoura — numa verificação de CI, num registo de problemas, num runbook —, deve usar-se o seu código, o identificador que sentinels.md lista para a condição e que se mantém fixo à medida que os pacotes à sua volta evoluem.
Uma interrupção por forma de Recipe compõe-se da mesma maneira. Começa com a frase que enuncia a regra, depois indica o que essa Recipe em particular forneceu e, em seguida, o detalhe que lhe é específico:
<the rule's sentence> (Recipe <name>:<version>, rule <rule-name>, at <position>). <rule-specific detail> (a frase da regra, depois a Recipe com nome e versão, o nome da regra e a posição; em seguida, o detalhe específico da regra)
A frase inicial é fixa para cada regra — o mesmo texto sempre que essa regra interrompe o build, seja qual for a fase que a detetou —, pelo que é a parte da saída com que comparar, e é o texto que sentinels.md lista para a condição da regra. Tudo o que vem depois varia consoante a Recipe com erro: os valores entre parênteses indicam qual o documento, qual a regra pelo nome e onde, e a frase final é o conselho para essa ocorrência. A posição é o ficheiro a partir do qual a Recipe foi carregada quando a regra diz respeito ao documento como um todo, e um caminho com pontos até à chave escrita — .spec.outputComponentLabels.hosting — quando a regra diz respeito a uma única coisa dentro dele; uma chave com pontos próprios não pode ser escrita como mais um segmento sem se ler igualmente como dois, pelo que o caminho para no bloco que a contém e o conselho cita a chave em vez disso.
O build imprime a linha inteira sob uma etiqueta CATALOG_ERROR, que sinaliza que a falha é atribuível à entidade do catálogo (a Recipe, ou o fornecedor ao qual se vincula), e não ao Aggregate nem à Release. O ficheiro a partir do qual a Recipe foi carregada é impresso ao lado da etiqueta, pelo que uma regra posicionada numa chave continua a indicar qual o ficheiro a abrir.
valuesMapping requires source (o mapeamento de valores requer uma origem)
Uma Recipe declara valuesMapping, mas não source. Sem uma origem sobre a qual sobrepor, não há nada que receba os valores mapeados. Esta regra é verificada quando a Recipe é carregada.
Mensagem emitida:
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 requer source; declarar um ponteiro source: junto de valuesMapping, ou remover o valuesMapping se não se pretender nenhuma sobreposição)
Como corrigir: adicionar um ponteiro source: (uma referência a um chart, módulo ou ficheiro compose) junto do valuesMapping, ou remover o valuesMapping e adotar um tipo de entrada diferente (workload: para saída sintetizada, artifacts: para emissão direta de manifestos).
workload: requires a provider that can synthesize (requer um fornecedor capaz de sintetizar)
Uma Recipe declara workload: (modo sintetizado) para um fornecedor que não implementa a síntese de Workload. O suporte do modo sintetizado é uma propriedade do fornecedor — o catálogo da biblioteca-padrão declara workloadSchema nos fornecedores capazes de síntese por convenção, mas a verificação baseia-se na capacidade do fornecedor, e não na presença desse campo.
Duas superfícies reportam-no, e só uma delas decide o build. A interrupção é levantada no momento da renderização, depois de o fornecedor do nó estar vinculado e de os tipos de entrada que a sua Recipe declara terem sido lidos, pelo que esse relatório indica o nó. aggrega validate reporta a mesma constatação mais cedo, antes de qualquer nó ser vinculado, lendo a Recipe isoladamente — pelo que esse relatório indica, em vez disso, a Recipe e a sua versão. Os dois não leem o mesmo conjunto de Recipes: o relatório antecipado é levantado para qualquer Recipe que declare workload:, enquanto a interrupção é levantada para cada tipo de entrada declarado pelo nó que o seu fornecedor não consegue satisfazer. Assim, uma Recipe que combine um workload: com um source: continua a ser interrompida, e é interrompida pelo workload — declarar um tipo de entrada que o fornecedor consegue renderizar não faz passar pela verificação um tipo não suportado.
O único limite a isso: artifacts: só é verificado em relação ao suporte de artefactos autónomos quando é o único tipo declarado do nó. Junto de um source: ou de um workload:, os seus ficheiros passam como saída composta, que essa capacidade não rege.
Mensagem emitida no momento da renderização. A categoria à qual a falha é atribuída chega no cabeçalho entre parênteses retos do diagnóstico, e não dentro da mensagem. A mensagem começa com a frase fixa que enuncia a condição e depois indica o nó, o fornecedor, o tipo declarado que foi recusado e os tipos que esse fornecedor suporta. Quando um nó declara dois tipos que o seu fornecedor não consegue satisfazer, é reportado o primeiro na ordem source → workload → artifacts, de modo que a constatação diz respeito a uma única linha da Recipe em causa:
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> (o fornecedor não suporta o tipo de entrada do nó; declarar um dos tipos de entrada suportados ou apontar para um fornecedor que suporte o modo)
O cabeçalho contém a categoria e o código curto desta condição, E0265, que é o identificador a registar quando for necessário nomear esta interrupção de forma duradoura — numa verificação de integração contínua, num registo de problemas ou num runbook. Um número é atribuído uma vez e depois fixado, pelo que se mantém igual por mais que a redação à sua volta melhore; a tabela de todas as condições resolve-o, e a frase inicial acima é aquilo com que comparar quando se parte do texto e não de um identificador.
aggrega validate reporta a mesma cláusula sob a Recipe que contém o bloco, com o prefixo da superfície que a leu e encabeçada pelo código curto desta condição, porque o relatório antecipado é a mesma condição:
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 (o fornecedor não suporta o modo sintetizado; declarar um dos tipos de entrada suportados ou apontar para um fornecedor que suporte o modo sintetizado)
Em todo o catálogo, é uma única linha; com --release, o cabeçalho fica numa linha própria acima da cláusula. O diagnóstico do editor para a mesma constatação tem E0265 como código.
Como corrigir: vincular a Recipe a um fornecedor que sintetize (mais habitualmente helm ou compose) ou migrar a Recipe para um tipo de entrada diferente (artifacts: para emissão direta de manifestos, ou source: + valuesMapping: se existir um chart/módulo).
Validação do conteúdo do Workload por fornecedor. Atualmente, o workloadSchema do fornecedor serve apenas de documentação e não valida o corpo do Workload; os corpos são validados em relação ao esquema de Workload incorporado, propriedade da plataforma. Quando o sintetizador de Workload baseado em Wasm for disponibilizado, workloadSchema passará a ser o contrato por fornecedor em relação ao qual o sintetizador valida o corpo do Workload (uma interrupção distinta, ao nível do conteúdo).
The provider does not support omits (O fornecedor não suporta omits)
Uma Recipe ou uma FeatureRecipe declara omits: e o fornecedor que a renderiza não declara que deixa documentos renderizados de fora. Deixar um documento de fora do que uma fonte renderiza é algo que só o fornecedor pode fazer — só o fornecedor sabe que documentos a fonte renderiza e como se chama cada um —, pelo que um fornecedor que não o faça renderizaria todos os documentos que as entradas nomeiam e comunicaria sucesso. Em vez disso, a compilação recusa antes de qualquer renderização, para que a chave nunca fique silenciosamente sem efeito.
Se um fornecedor deixa documentos de fora é lido da própria declaração do fornecedor sobre o que suporta, não de uma lista de fornecedores mantida pelo compilador. Todas as entradas contam, seja o que for que o seu when: renderize, porque a capacidade do fornecedor de respeitar a chave não depende de que entradas uma compilação mantém. Os fornecedores helm, compose e cloudformation respeitam a chave. helm-chart e terraform passam a sua fonte adiante para ser renderizada quando é implementada, pelo que no momento da compilação não existe nenhum documento renderizado a deixar de fora, e ambos são recusados.
A recusa é decidida assim que a Recipe de cada componente e a FeatureRecipe de cada anexo estão vinculadas e cada fornecedor se descreveu a si próprio — antes de o primeiro componente ser renderizado e antes de qualquer entrada ser avaliada, pelo que uma compilação recusada aqui não renderiza nada. A verificação é feita a todos os documentos que renderizam uma fonte: a Recipe de um componente; a FeatureRecipe que um anexo vincula a um componente, uma vez por cada componente que tem o anexo; e uma FeatureRecipe que gera uma única vez para uma fronteira, uma vez, na fronteira que a declara. Todos os documentos em falta são comunicados numa única compilação; quando há mais de um, as constatações são agrupadas sob documents declaring omits whose provider does not honour them. Um documento vinculado a um fornecedor que a compilação não consegue resolver não é comunicado aqui: essa compilação é interrompida onde o fornecedor é selecionado, indicando o vínculo.
Mensagem emitida, posicionada na própria chave do componente sob components: para as entradas de uma Recipe (um componente escrito dentro de um subsistema é posicionado primeiro sob a chave desse subsistema), na chave do anexo no bloco features: que o escreveu para as de uma FeatureRecipe num componente, e em .spec.boundaries.<boundary>.features.<attachment> na Release para uma FeatureRecipe que gera uma única vez para a sua fronteira. A categoria chega no cabeçalho entre colchetes; a mensagem indica primeiro o fornecedor e depois o componente para o qual o documento é renderizado:
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 (o fornecedor não suporta omits: o contrato deste fornecedor não declara que deixa documentos renderizados de fora; remova a chave omits ou renderize a fonte através de um fornecedor cujo contrato o declare)
A constatação de uma FeatureRecipe indica o anexo depois do componente — node "<node-id>", attachment "<attachment>" — e a de uma FeatureRecipe que gera uma única vez para a sua fronteira indica a fronteira e o anexo em vez de um componente: boundary "<boundary>", attachment "<attachment>".
O cabeçalho apresenta o código curto desta condição, E0335.
Como corrigir: remova a chave omits: ou renderize a fonte através de um fornecedor que a respeite. Quando uma Recipe helm-chart ou terraform usa como fonte um chart ou módulo local, uma linha no .aggregaignore ao lado da Recipe deixa antes de fora um ficheiro dessa fonte, a partir da próxima vez que a Recipe for fixada — consulte aggrega pin.
The provider does not support boundary artifacts (O fornecedor não suporta artefactos de fronteira)
Uma Recipe declara spec.boundary.artifacts — ficheiros para a saída partilhada da fronteira em que é renderizada — e o fornecedor que a renderiza não declara que aceita tais ficheiros. O próprio compilador escreve esses ficheiros, ao lado do que o fornecedor monta para a fronteira, e não entrega nenhum deles ao fornecedor, pelo que saber se um ficheiro colocado ali significa alguma coisa é uma propriedade do destino do fornecedor. Um destino que não o leia entregá-lo-ia e ignorá-lo-ia, e a configuração que contém nunca produziria efeito; em vez disso, a compilação recusa antes de qualquer renderização.
Se um fornecedor aceita os ficheiros é lido da própria declaração do fornecedor sobre o que suporta, não de uma lista de fornecedores mantida pelo compilador. Qualquer entrada conta, seja qual for o resultado da sua renderização. O fornecedor terraform aceita-os, escrevendo cada um ao lado da configuração raiz da fronteira; helm, compose, helm-chart e cloudformation não, e são recusados.
A recusa é decidida assim que a Recipe de cada componente está vinculada e cada fornecedor se descreveu a si próprio — antes de o primeiro componente ser renderizado e antes de qualquer entrada ser avaliada, pelo que uma compilação recusada aqui não renderiza nada. Cada Recipe em falta é comunicada numa única compilação, uma vez por cada componente que renderiza; quando há mais de uma constatação, são agrupadas sob Recipes declaring boundary artifacts whose provider does not accept them. Uma Recipe vinculada a um fornecedor que a compilação não consegue resolver não é comunicada aqui: essa compilação é interrompida onde o fornecedor é selecionado, indicando o vínculo.
Mensagem emitida, posicionada em .spec.boundary na Recipe, onde a edição deve ser feita. A categoria chega no cabeçalho entre colchetes; a mensagem indica primeiro o fornecedor e depois o componente para o qual a Recipe é renderizada:
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 (o fornecedor não suporta artefactos de fronteira: o contrato deste fornecedor não declara que aceita ficheiros escritos na saída partilhada de uma fronteira; remova o bloco boundary ou renderize a Recipe através de um fornecedor cujo contrato o declare)
O cabeçalho apresenta o código curto desta condição, E0351.
Como corrigir: remova o bloco boundary: ou renderize a Recipe através de um fornecedor que o aceite. Um ficheiro que pertence ao componente e não à fronteira é, em vez disso, uma entrada de artifacts:.
At least one input kind must be present (Tem de estar presente pelo menos um tipo de entrada)
Uma Recipe não declara nenhum tipo de entrada: nenhuma source combinada com valuesMapping, nenhum workload:, nenhum artifacts:. Uma Recipe deste tipo não produz saída e não tem superfície de renderização. Esta regra é verificada quando a Recipe é carregada.
Um ficheiro de Recipe com essa forma depara primeiro com o esquema da Recipe: o esquema exige, em qualquer fornecedor, um de source, valuesMapping, workload ou artifacts, pelo que a verificação do envelope do documento recusa o ficheiro com E0215 antes de esta regra ser executada, com um ramo para cada chave:
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 (a validação do envelope do documento falhou (Recipe): spec: nenhum ramo anyOf correspondeu: ramo[0]: validação: obrigatório: propriedades em falta: [“source”]; ramo[1]: validação: obrigatório: propriedades em falta: [“valuesMapping”]; ramo[2]: validação: obrigatório: propriedades em falta: [“workload”]; ramo[3]: validação: obrigatório: propriedades em falta: [“artifacts”]. corrija o documento para que corresponda ao esquema do seu tipo)
Mensagem emitida:
Recipe: at least one input kind required (Recipe <name>:<version>, rule input-kinds, at <path>). declare one of: source (with valuesMapping), workload, artifacts (Recipe: é obrigatório pelo menos um tipo de entrada (Recipe, regra input-kinds). declare um de: source (com valuesMapping), workload, artifacts)
Como corrigir: adicione o tipo de entrada que corresponde à intenção com que a Recipe foi escrita. Uma Recipe para um serviço que a compilação não aprovisiona — uma base de dados ou uma API que já é executada noutro local — declara um workload: de form: reference com o seu endpoint (e opcionalmente port) e publica os seus valores de ligação sob provides: como qualquer Recipe: helm renderiza-a como um ExternalName Service, compose não renderiza nada para ela e, em ambos, os seus consumidores leem os valores publicados.
artifacts: entry keys must be unique (As chaves das entradas de artefactos têm de ser únicas)
Uma Recipe declara duas ou mais entradas sob artifacts: com a mesma chave. A chave determina o nome do ficheiro emitido (quer o corpo da entrada seja escrito inline, quer seja carregado através de um $import: por entrada); chaves duplicadas emitiriam um ficheiro com o mesmo nome para o mesmo diretório da fronteira.
A compilação recusa a Recipe ao descodificar o documento para a sua forma tipada, indicando a chave repetida e a linha em que se repete. Esse passo é executado depois da verificação do esquema do envelope e antes das regras de forma, pelo que uma Recipe com uma chave artifacts: duplicada comunica um esquema válido e depois esta interrupção, e as restantes regras de forma não comunicam nada sobre ela.
Como corrigir: mude o nome de uma das chaves de entrada em colisão para que cada entrada de artifacts: tenha um nome de ficheiro único.
Emission-time filename collision across input kinds (Colisão de nomes de ficheiro no momento da emissão entre tipos de entrada)
Uma Recipe e uma FeatureRecipe declaram, cada uma, tipos de entrada que produzem ficheiros: uma source: que o fornecedor renderiza, um workload: que o fornecedor sintetiza, entradas de artifacts: e um pipeline: cujos passos podem emitir. Cada um deles escolhe os seus nomes de saída independentemente dos outros, e nada declara esses nomes como distintos — pelo que dois deles podem produzir um ficheiro sob um único nome, e só um dos dois sobreviveria. A compilação é interrompida e indica o nome de saída juntamente com cada bloco que o produziu.
A verificação é executada uma vez por documento emissor, assim que a emissão do próprio documento termina e antes de a sua saída entrar em qualquer montagem. Três documentos emitem, e cada um é verificado separadamente: a Recipe do próprio componente, a FeatureRecipe que um anexo vincula a um componente e a FeatureRecipe que um anexo com âmbito de fronteira vincula. Mantê-los separados é o que faz o diagnóstico indicar o documento certo — os ficheiros de um anexo são renderizados sob a identidade do componente que o aloja, pelo que uma colisão na FeatureRecipe do anexo é comunicada contra essa FeatureRecipe e não contra o componente anfitrião.
Cada nome em colisão é comunicado separadamente, pelo que um documento cujos blocos coincidiram em dois nomes comunica ambos. Uma constatação é posicionada no documento que se edita para a corrigir: a instância do componente para uma Recipe, e a própria FeatureRecipe para um anexo, cuja constatação também indica o anexo — um componente ou uma fronteira pode vincular vários.
Um bloco que emite vários ficheiros sob um mesmo nome não é esta interrupção. Trata-se de um único contribuinte, e não de dois blocos que coincidem, e chaves artifacts: duplicadas dentro de um bloco são recusadas enquanto o documento é descodificado.
Mensagem emitida:
filename collision across input kinds: two input-kind blocks produced a file under one output name (output name <filename>, produced by <origin1>, <origin2>) (colisão de nomes de ficheiro entre tipos de entrada: dois blocos de tipo de entrada produziram um ficheiro sob um mesmo nome de saída)
Uma colisão numa FeatureRecipe indica também o anexo:
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>) (colisão de nomes de ficheiro entre tipos de entrada: dois blocos de tipo de entrada produziram um ficheiro sob um mesmo nome de saída)
Como corrigir: mude o nome do ficheiro em colisão no tipo de entrada que controla. Se a colisão envolver um nome de ficheiro traduzido pelo Workload e uma entrada de artifacts:, os nomes traduzidos pelo Workload seguem as convenções de tradução do fornecedor (por exemplo, <release-name>-deployment.yaml para helm, em que o nome da release é {{ .context.rendered_name }}) — ajuste o nome de ficheiro de artifacts: para um nome que o fornecedor não sintetize.
An output-label key uses a reserved namespace (Uma chave de etiqueta de saída usa um espaço de nomes reservado)
Uma Recipe indica uma chave de etiqueta sob aggrega.ai/ ou app.kubernetes.io/ — em outputLabels:, o bloco que aplica etiquetas literais à saída renderizada, ou em outputComponentLabels:, o bloco que indica chaves de etiqueta do componente cujos valores são promovidos para ela. Ambos os prefixos pertencem ao próprio espaço de chaves de proveniência da plataforma: são as chaves que a própria compilação aplica, pelo que uma Recipe que aplicasse uma delas estaria a escrever no espaço que diz de onde veio um recurso. Reservá-los é também o que mantém o conjunto de etiquetas de uma Recipe disjunto do conjunto de proveniência, para que os dois nunca tenham de ser reconciliados quando são fundidos. Esta regra é verificada quando a Recipe é carregada.
A reserva aplica-se apenas à raiz simples. Uma chave que apenas contém uma raiz reservada mais a fundo, dentro de um espaço de nomes próprio — component.aggrega.ai/hosting, por exemplo — é um espaço de chaves diferente que não pertence à plataforma, e continua a poder ser usada.
Mensagem emitida. Uma única condição abrange os dois blocos, pelo que a sua frase não pode dizer qual dos dois foi escrito; a indicação que se segue nomeia o bloco citando a chave escrita e o bloco em que foi escrita:
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) (restrição output-labels da receita: a chave usa um espaço de nomes reservado (Recipe, regra output-labels). a chave em outputLabels usa um espaço de nomes reservado (os dois prefixos estão reservados para a proveniência da plataforma))
Uma chave escrita no bloco promovido é comunicada sob o nome de regra desse bloco, que a indicação nomeia:
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) (restrição output-labels da receita: a chave usa um espaço de nomes reservado (Recipe, regra output-component-labels). a chave em outputComponentLabels usa um espaço de nomes reservado (os dois prefixos estão reservados para a proveniência da plataforma))
As chaves do bloco literal são verificadas depois de ordenadas e as do bloco promovido pela ordem em que foram escritas, pelo que uma Recipe que viola a regra em vários pontos comunica sempre a mesma chave em primeiro lugar.
Como corrigir: mova a chave para um espaço de nomes próprio — o seu domínio, ou um com subprefixo como component.aggrega.ai/… — ou remova-a se o valor pretendido for um que a compilação já aplica. As chaves de proveniência que um recurso renderizado contém estão listadas em ../providers/well-known-annotations.md; voltar a ler uma delas não exige nenhuma declaração na Recipe.
A promoted component label is also declared literally (Uma etiqueta de componente promovida também é declarada literalmente)
Uma Recipe indica uma mesma chave tanto em outputComponentLabels: como em outputLabels:. Os dois blocos aplicam valores na mesma superfície de etiquetas a partir de fontes diferentes — o primeiro promove o valor que o componente contém, o segundo escreve o valor que o autor da Recipe introduziu —, pelo que uma chave indicada em ambos chegaria com dois valores candidatos e nada que diga qual prevalece. Esta regra é verificada quando a Recipe é carregada, depois da regra do espaço de nomes reservado acima, pelo que uma Recipe que viole ambas comunica primeiro o espaço de nomes reservado: a correção dessa falha não depende do que o outro bloco contém.
Mensagem emitida:
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 (restrição output-component-labels da receita: a chave também está declarada em outputLabels (Recipe, regra output-component-labels). a chave é promovida através de outputComponentLabels e também declarada literalmente em outputLabels; mantenha a fonte de onde a etiqueta deve vir e remova a outra)
Como corrigir: decida de onde vem o valor da etiqueta e elimine a outra declaração. Mantenha a entrada de outputComponentLabels: quando o valor deve acompanhar o que o componente contém, para que dois componentes vinculados a uma mesma Recipe apliquem os seus próprios valores; mantenha a entrada de outputLabels: quando o valor é da própria Recipe e é o mesmo onde quer que a Recipe esteja vinculada.
Regras de forma da FeatureRecipe
Uma FeatureRecipe compõe a sua saída a partir dos mesmos tipos de entrada que uma Recipe, e a regra de composição abaixo restringe-a como restringe uma Recipe. É verificada quando a FeatureRecipe é carregada e comunica no formato que uma interrupção de forma de Recipe assume — a frase da regra, depois o documento em falta, o nome da regra e a indicação para essa ocorrência — sob uma etiqueta CATALOG_ERROR.
Aqui, deliberadamente, não existe nenhuma regra de pelo menos um tipo de entrada, e essa é a diferença em relação a uma Recipe. Uma FeatureRecipe que declara apenas um fornecedor e aquilo que implementa é um anexo legítimo de pura cablagem: não renderiza nada, e o seu efeito é a ligação que a Feature que implementa contém. Uma FeatureRecipe que declara apenas injectMapping: é legítima da mesma forma.
A FeatureRecipe’s valuesMapping requires source (O mapeamento de valores de uma FeatureRecipe exige uma origem)
Uma FeatureRecipe declara valuesMapping, mas não source. Um mapeamento de valores é uma sobreposição, pelo que, sem um chart, um módulo ou um ficheiro sobre o qual se sobrepor, os valores mapeados não têm nada a que chegar.
Mensagem emitida:
FeatureRecipe: valuesMapping requires source (FeatureRecipe <name>:<version>, rule values-mapping, at <path>). declare a source: pointer alongside valuesMapping (or remove the valuesMapping if no overlay is intended) (FeatureRecipe: valuesMapping exige source (FeatureRecipe, regra values-mapping). declare um ponteiro source: junto de valuesMapping (ou remova o valuesMapping se não se pretender nenhuma sobreposição))
Como corrigir: adicione o ponteiro source: para o qual a sobreposição foi escrita, ou remova o valuesMapping e deixe o anexo fazer o seu trabalho de outra forma — artifacts: para emitir ficheiros próprios, injectMapping: para remodelar o que entrega, ou nenhum dos dois, para um anexo de pura cablagem.
A pipeline declares one step id twice (Um pipeline declara duas vezes o mesmo id de passo)
Uma Recipe ou FeatureRecipe declara o mesmo id em dois passos do seu spec.pipeline. Um passo publica as saídas que devolve sob o seu id, e um passo posterior do mesmo pipeline lê-as como .steps.<id>.outputs, pelo que dois passos que partilhassem um id levariam esse passo posterior a ler as saídas daquele dos dois que publicou em último lugar, em vez das daquele que se pretendia.
A regra abrange o pipeline próprio de um documento. A Recipe de um componente e as FeatureRecipes anexadas a ele executam cada uma o seu pipeline separadamente, e cada pipeline começa sem saídas de passos, pelo que um passo de uma Recipe e um passo de uma FeatureRecipe anexada podem ter o mesmo id.
Nenhum schema consegue exprimir esta regra — o JSON Schema não tem nenhuma palavra-chave para uma lista cujas entradas sejam únicas por um dos seus campos —, pelo que um editor que conhece o schema aceita um documento destes, e a verificação é executada à medida que o documento é lido, logo após a verificação do schema. Todas as superfícies que leem uma Recipe ou FeatureRecipe reportam-na: aggrega validate sobre o ficheiro ou sobre o catálogo inteiro, uma compilação que carrega o catálogo, um pull que admite uma entidade obtida, os diagnósticos do editor e uma edição de documento, que é recusada em vez de escrita. Um documento que também falha o seu schema reporta primeiro as constatações do schema, e esta recusa depois de estas serem corrigidas.
Cada repetição é uma constatação própria, posicionada no id repetido e nomeando o passo que declarou o id primeiro, com a sua linha e coluna. Quando um id aparece três vezes, os dois passos posteriores nomeiam o primeiro.
Mensagem emitida, para uma FeatureRecipe cujo segundo passo repete o id do primeiro. A categoria e o código curto desta condição, E0370, chegam no cabeçalho entre parênteses retos:
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 (um pipeline declara duas vezes o mesmo id de passo (FeatureRecipe); spec.pipeline[1].id: o id de passo já está declarado em spec.pipeline[0].id. dê a cada passo do pipeline o seu próprio id, e aponte cada referência que um passo posterior faz para o passo a que se refere)
Como corrigir: mude o nome de um dos dois passos, para que cada id seja declarado uma única vez. Em seguida, leia os templates with: e when: de cada passo posterior à procura de referências .steps.<id> ao id que manteve, e aponte cada uma para o passo cujas saídas pretende — é a mudança de nome que torna as saídas dos dois passos alcançáveis separadamente.
A document declares an API version this compiler no longer reads (Um documento declara uma versão de API que este compilador já não lê)
A linha apiVersion de um documento declara aggrega.ai/v1alpha1. Todos os tipos de documento que contêm uma linha apiVersion declaram aggrega.ai/v1beta1, a única versão que este compilador lê, e não ocorre qualquer conversão a partir da versão anterior: o documento é recusado ao ser lido, antes de qualquer outra verificação, porque qualquer outra constatação diria respeito a uma versão do documento que o compilador não lê.
Todas as superfícies que leem um documento reportam-no: aggrega validate, uma compilação, um pull que admite uma entidade obtida, os diagnósticos do editor e uma edição de documento. Um documento que declara uma versão que o compilador nunca leu é, em vez disso, recusado pelo esquema do seu tipo, com E0215.
Mensagem emitida, para um Component. A categoria e o código curto desta condição, E0373, chegam-lhe no cabeçalho entre parênteses retos:
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 (um documento declara uma versão de API que este compilador já não lê (Component); 1:1: apiVersion: o documento declara aggrega.ai/v1alpha1, e este compilador lê aggrega.ai/v1beta1. altere a linha apiVersion para aggrega.ai/v1beta1)
Como corrigir: altere a linha apiVersion do documento para apiVersion: aggrega.ai/v1beta1. Os campos de cada tipo não mudam entre as duas versões, pelo que essa linha é toda a alteração.
A plugin declares a plugin ABI version this compiler no longer speaks (Um plugin declara uma versão da ABI de plugins que este compilador já não suporta)
Um plugin declara a ABI de plugins v1alpha1. Este compilador suporta a ABI de plugins v1beta1 e nenhuma outra, pelo que um plugin compilado para a anterior é recusado em vez de executado. Um plugin indica a sua ABI em dois sítios, e cada um é recusado com esta mesma condição: o relatório describe() que o seu módulo convidado devolve ao ser carregado, e o campo spec.abiVersion da sua entidade Plugin, recusado quando a entidade é lida, antes de qualquer outra verificação. Um plugin que declara uma versão de ABI que este compilador nunca suportou também é recusado, pela verificação do descritor (E0085) ou pelo esquema Plugin (E0215).
Mensagem emitida, para um módulo convidado no carregamento. A categoria e o código curto desta condição, E0374, chegam-lhe no cabeçalho entre parênteses retos:
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 (o plugin declara abi_version “v1alpha1”, e este compilador suporta “v1beta1”; recompile o plugin com o kit de plugins atual e publique-o novamente: um plugin declara uma versão da ABI de plugins que este compilador já não suporta)
Mensagem emitida, para uma entidade 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 (um plugin declara uma versão da ABI de plugins que este compilador já não suporta (Plugin); spec.abiVersion: o Plugin declara abiVersion v1alpha1, e este compilador suporta v1beta1. recompile o plugin com o kit de plugins atual e publique-o novamente; a sua entidade Plugin passa então a declarar abiVersion v1beta1)
Como corrigir: recompile o plugin com a versão atual do seu kit de plugins, que grava v1beta1 no relatório describe() do módulo convidado, e publique-o novamente, para que a entidade gerada ao lado dele também declare abiVersion: v1beta1. Editar apenas a linha da entidade não chega: o próprio módulo convidado continua a reportar a ABI anterior e é recusado quando é carregado.
An artifact carries a media type this compiler no longer reads (Um artefacto contém um tipo de média que este compilador já não lê)
Um artefacto obtido de um registo contém um tipo de média com que uma versão anterior publicava — application/vnd.aggrega.<kind>.v1alpha1 com o seu sufixo, no tipo de artefacto do manifesto, na sua configuração ou numa das suas camadas. Este compilador publica e lê os tipos de média v1beta1, pelo que o artefacto é recusado pelo nome quando o seu manifesto é lido, antes de ser obtida qualquer parte do seu conteúdo: seja uma entidade de catálogo, um plugin e o seu executável ou um pacote de documentação. Uma indexação de um registo ignora um artefacto destes, indicando o motivo. Um tipo de média fora do espaço de nomes application/vnd.aggrega. próprio do Aggrega nunca corresponde a esta condição.
Mensagem emitida, para um Component publicado por uma versão anterior. A categoria e o código curto desta condição, E0375, chegam-lhe no cabeçalho entre parênteses retos:
"<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 (contém o tipo de média “application/vnd.aggrega.component.v1alpha1+yaml”, e este compilador lê “application/vnd.aggrega.component.v1beta1+yaml”; publique o artefacto novamente com a versão atual: oci: o artefacto contém um tipo de média que este compilador já não lê)
Como corrigir: publique o artefacto novamente com a versão atual do aggrega, que grava os tipos de média v1beta1. Um artefacto publicado por outra pessoa cabe a essa pessoa publicar novamente; até que o faça, não pode ser lido.
A file cannot be read, or its bytes do not parse (Um ficheiro não pode ser lido, ou os seus bytes não são analisáveis)
Um ficheiro que uma compilação tinha de ler, ou um documento Aggrega que uma verificação do catálogo inteiro leu nos diretórios do catálogo, não produziu nada que a superfície que o nomeou ou leu pudesse usar. Ou não pôde ser lido do disco, ou os seus bytes foram analisados e a análise não foi concluída de forma limpa. Nada a jusante é executado sobre ele, porque não há conteúdo para verificar face a um schema, nenhum componente para posicionar e nenhum template para renderizar.
A condição não nomeia nenhum formato, e isso é intencional. A maioria dos ficheiros que abrange é lida como YAML; os corpos workload, values-mapping e artifact de uma Recipe são lidos como código-fonte de template Go e nunca são analisados. Uma frase que prometesse YAML iniciaria um diagnóstico sobre um ficheiro de template com uma afirmação sobre o formato desse ficheiro. Qual das duas falhas ocorreu, e para que tipo de ficheiro, é o que diz a oração a seguir à frase.
Os documentos de que uma compilação parte — o Aggregate, a Release e o Manifest — são os assuntos mais comuns, e a interrupção é levantada em todos os pontos em que um dos três é lido. O diagnóstico nomeia o documento que estava a ser lido e o caminho de onde foi lido. O caminho é o que distingue um ficheiro em falta de um malformado: uma falha de leitura cita o motivo do próprio sistema operativo, e uma falha de análise cita o do parser YAML, que indica a linha em que o parser desistiu.
Mensagem emitida, quando o ficheiro não pôde ser lido:
file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to read file: <underlying reason>) (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Aggregate, falha ao ler o ficheiro))
e quando o seu texto não foi analisável:
file load failed: the file could not be read, or its bytes did not parse (Aggregate, at <path>, failed to unmarshal YAML: <underlying reason>) (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Aggregate, falha ao desserializar o YAML))
Release e Manifest aparecem no lugar de Aggregate quando um destes é o documento a ser lido. A mesma condição abrange também o contrato de parâmetros lido do bloco parameters: declarado de um Aggregate, que é lido do próprio texto do Aggregate antes de nele ser interpolado o que quer que seja.
Um parameters: { $import: … } de uma Release que nomeia um ficheiro a que a compilação não consegue aceder também é reportado aqui, e em ambos os casos: o caminho não nomeia nenhum ficheiro que a compilação possa ler, ou o ficheiro é lido e os seus bytes não são analisáveis. O assunto é a Release, e a oração nomeia a chave que apontava para o ficheiro:
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>) (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Release, falha ao ler o ficheiro)) 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>) (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Release, falha ao desserializar o YAML))
Um caminho relativo é resolvido a partir do diretório que contém a Release que o escreve — a Release que um comando nomeia, ou um elo da sua cadeia extends: —, seja qual for o local a partir do qual o comando é executado, de modo que a linha de comandos e o editor leem o mesmo ficheiro; um caminho absoluto nomeia o seu próprio lugar. Confirme que o checkout sobre o qual a compilação é executada contém o ficheiro nesse local: um ficheiro de parâmetros presente na sua máquina e excluído do controlo de versões está ausente durante uma execução de integração contínua, que é a forma comum de se deparar com este erro. Um caminho que sai do workspace — ou, para uma Release nomeada fora do workspace, do diretório próprio dessa Release — não é lido de todo, e é reportado em «A reference to another file leads out of the directory it must stay inside» (Uma referência a outro ficheiro sai do diretório em que tem de permanecer) mais abaixo.
Um $import: de schema que nomeia um ficheiro a que a compilação não consegue aceder também é reportado aqui, porque a falha é a mesma: a diretiva está bem formada e o ficheiro que nomeia não produziu um documento. O assunto é então uma entidade de catálogo e não um dos três, pelo que a oração nomeia a superfície de schema para a qual estava a resolver — spec.schema, um dos seus pilares como spec.schema.values, ou o valueSchema de um socket usesSchema — e o ponteiro de origem é a linha em que a diretiva foi escrita:
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> (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis. leitura do schema importado)
com resolve imported schema path no lugar de read para a falha mais rara de nem sequer se conseguir estabelecer o diretório próprio da entidade, e parse imported schema quando o ficheiro foi lido e o seu texto não é YAML bem formado. Uma falha na diretiva que escreveu — uma chave irmã ao lado dela, um valor que não é um caminho, ou conteúdo importado que foi analisado e não é um mapa — é uma condição diferente e é reportada em «A schema $import: cannot be applied» (Uma importação de schema não pode ser aplicada) mais abaixo.
Uma importação valuesMapping:, workload: ou artifacts.<name>: de uma Recipe ou FeatureRecipe também é reportada aqui, pelo mesmo motivo e com a mesma solução: a diretiva está bem formada e o ficheiro que nomeia não produziu conteúdo. Esses três corpos são código-fonte de template Go e não documentos, pelo que só a leitura pode falhar — nada os analisa neste ponto. A entidade e a chave que nomeou o caminho seguem na oração, e o ponteiro de origem é o caminho do próprio ficheiro 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 (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Recipe, importação de ficheiro valuesMapping). se pretendia uma entrada de biblioteca e não um ficheiro, a referência precisa do seu fragmento — um $import: sem nenhum é lido como caminho de ficheiro, e um valor sem aspas termina onde um espaço antes de # inicia um comentário, por isso coloque a referência inteira entre aspas) 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 (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Recipe, importação de ficheiro workload). se pretendia uma entrada de biblioteca e não um ficheiro, a referência precisa do seu fragmento — um $import: sem nenhum é lido como caminho de ficheiro, e um valor sem aspas termina onde um espaço antes de # inicia um comentário, por isso coloque a referência inteira entre aspas) 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 (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (Recipe, importação de ficheiro de um artifact). se pretendia uma entrada de biblioteca e não um ficheiro, a referência precisa do seu fragmento — um $import: sem nenhum é lido como caminho de ficheiro, e um valor sem aspas termina onde um espaço antes de # inicia um comentário, por isso coloque a referência inteira entre aspas)
O fragmento é o que distingue uma referência de biblioteca de um caminho: <Library>#/mappings/<entry> é resolvido face às bibliotecas, e o mesmo texto sem o fragmento é um caminho relativo comum. É fácil perdê-lo sem dar por isso, porque um valor YAML simples termina onde um espaço antes de # abre um comentário — assim, $import: LibBeta:1.0.0 #/workloads/Web chega à compilação como LibBeta:1.0.0, e a compilação procura então um ficheiro com esse nome junto da Recipe. Coloque a referência inteira entre aspas para manter o fragmento.
As mesmas três chaves numa FeatureRecipe reportam a mesma condição e leem-se da mesma forma. Uma importação de artifacts é lida duas vezes ao longo da vida de uma Release — uma vez quando aggrega pull congela o pin do seu conteúdo, e de novo quando a entrada é renderizada —, pelo que o mesmo ficheiro em falta reporta esta condição naquele dos dois momentos que for atingido primeiro. Uma falha de forma na própria diretiva, como uma chave irmã ao lado de $import: ou uma referência oci:// que inclui um host, é uma condição diferente e é reportada na sua própria entrada.
aggrega lint e aggrega validate sobre o catálogo inteiro também reportam aqui, para um documento num diretório do catálogo que declara uma apiVersion Aggrega — uma linha que começa, sem indentação, com apiVersion: e um valor iniciado por aggrega.ai/ — e que não pode ser lido, não é analisável ou não se descodifica no envelope que a verificação lê, como um metadata escrito como lista. Nenhum autor escreveu um caminho até ele: a verificação leu-o porque se encontra num diretório de catálogo. Cada verificação lê todos os ficheiros antes de parar, pelo que uma única execução nomeia cada um desses documentos; não verifica mais nada e não imprime nenhum resumo. O YAML que não declara nenhuma apiVersion Aggrega — entre ele os templates de um chart Helm — é ignorado. O cabeçalho conta os documentos e nomeia os seus ficheiros, e cada um é listado por baixo com o motivo indicado pela leitura ou pelo parser:
<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (documentos nos diretórios do catálogo declaram uma apiVersion Aggrega e não puderam ser carregados, pelo que nada foi verificado) 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>) (falha ao carregar o ficheiro: o ficheiro não pôde ser lido, ou os seus bytes não foram analisáveis (documento de catálogo, falha ao desserializar o YAML))
com failed to decode the envelope: e a linha e o que o descodificador lá encontrou — line 4 (metadata): a list is written where a map is expected para um metadata escrito como lista — para um documento que é analisável e não se descodifica, e failed to read file: e o motivo do sistema operativo para um ficheiro que não pôde ser lido. Um documento que é carregado e declara um tipo que nenhum catálogo contém é nomeado pela mesma interrupção, contado no mesmo cabeçalho e listado sob a sua própria condição — consulte «A catalog document declares a kind a catalog does not hold» (Um documento de catálogo declara um tipo que um catálogo não contém) mais abaixo.
Como corrigir: leia o caminho na mensagem e não o nome do documento — os dois diferem sempre que uma referência foi resolvida num local inesperado. Para uma falha de leitura, confirme que o ficheiro existe nesse caminho, que o caminho está escrito como o documento que o referencia o escreve, e que a compilação tem permissão para o ler; um ficheiro presente localmente e ausente do checkout de um agente de compilação é o caso comum. Para uma falha de análise, abra o ficheiro na linha que o parser nomeou — um valor sem aspas que contém dois pontos, uma tabulação usada para indentação e um item de lista indentado sob a chave errada são os três que explicam a maioria delas.
A catalog document declares a kind a catalog does not hold (Um documento de catálogo declara um tipo que um catálogo não contém)
Um documento nos diretórios do catálogo declara uma apiVersion Aggrega — uma linha que começa, sem indentação, com apiVersion: e um valor iniciado por aggrega.ai/ — e um kind que nenhum catálogo contém: um erro de escrita como Componnent, um tipo com maiúsculas e minúsculas erradas como component, ou nenhum kind. Um catálogo arquiva cada documento sob o tipo que declara, pelo que um documento destes não entra em nenhum catálogo: uma compilação, inspect e qualquer outro comando que carregue o catálogo ignoram-no, e uma referência à entidade que deveria declarar não se resolve em nada.
Um catálogo contém documentos Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate e Plugin. Três outros tipos encontram-se legitimamente nos seus diretórios e nunca são reportados aqui: um Manifest e uma Release mantidos junto das entidades, e um Workload no diretório da Recipe ou FeatureRecipe que o importa.
aggrega validate e aggrega lint sobre o catálogo inteiro reportam-no, assim como o lint restrito a uma release, que percorre os mesmos diretórios. Cada um lê todos os ficheiros antes de parar, pelo que uma única execução nomeia cada um desses documentos juntamente com qualquer documento que não possa ser carregado de todo, sob um único cabeçalho que os conta e nomeia os seus ficheiros; nada é verificado e nenhum resumo é impresso. Cada documento é listado com o tipo que declara, e a linha termina com os tipos que um catálogo contém:
<n> documents under the catalog directories declare an Aggrega apiVersion and could not be loaded, so nothing was checked: <path>, <path> (documentos nos diretórios do catálogo declaram uma apiVersion Aggrega e não puderam ser carregados, pelo que nada foi verificado) 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 (um documento de catálogo declara um tipo que um catálogo não contém (kind “Componnent”). um catálogo contém documentos Component, Feature, Recipe, FeatureRecipe, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary, Aggregate e Plugin, e ignora um Workload, um Manifest ou uma Release; corrija o kind, ou mova o ficheiro para fora dos diretórios do catálogo)
com no kind no lugar de kind "<kind>" para um documento que não declara nenhum.
Uma compilação não para perante um documento destes: ignora-o como todos os carregamentos fazem, e um documento que nenhuma Release alcança nunca faz falhar uma compilação. Quando uma Release alcança a entidade, a compilação para na referência, em «A reference names no entity the catalog holds» (Uma referência não nomeia nenhuma entidade que o catálogo contenha) mais abaixo, e a nota sob essa falha nomeia o ficheiro quando este declara o nome que a referência pede — consulte essa entrada.
Como corrigir: abra o ficheiro que a mensagem nomeia e corrija o seu kind para o tipo que o documento é — tanto a grafia como as maiúsculas e minúsculas contam. Um ficheiro que não é de todo uma entidade de catálogo não pertence aos diretórios do catálogo; mova-o para fora, ou atribua-lhe uma apiVersion que não seja a do Aggrega se for o documento de outra ferramenta.
A path names content outside the entity’s own directory (Um caminho designa conteúdo fora do diretório da própria entidade)
O conteúdo de uma entidade reside no diretório da própria entidade, porque cada ficheiro que uma publicação da entidade transporta é obtido daí. Um caminho que sai dele aponta para um ficheiro que não viajaria com a entidade; assim, o ficheiro não está presente para quem recebe a entidade, e um pin registado sobre ele garante bytes que esses destinatários não conseguem obter.
Por isso, cada caminho que uma entidade escreve para conteúdo que transporta é lido relativamente ao diretório que contém o ficheiro da entidade e tem de permanecer dentro dele. Isto abrange a source: de uma Recipe e de uma FeatureRecipe — um caminho simples, ou a url: da forma estruturada —, o ficheiro que cada entrada de valuesMapping:, workload: e artifacts: importa com $import:, e cada esquema que um Component ou uma Feature importa, completo, por pilar ou, para um socket usesSchema, o seu valueSchema e o seu infraSchema. Três formas saem do diretório: um caminho que sobe acima dele, um caminho absoluto, que designa um local na máquina em que foi escrito, e um caminho escrito dentro do diretório que uma ligação simbólica no percurso leva para fora dele — um diretório ao longo do caminho, tal como o ficheiro no seu fim, que seja uma ligação que conduz para fora do diretório da entidade. Um caminho que sobe e volta a entrar — ./charts/../values.tmpl — é um caminho comum dentro do diretório, e o mesmo acontece com um que passa por uma ligação que conduz a outro ponto dentro dele. Uma subida que volta a entrar no diretório pelo seu próprio nome — ../1.0.0/values.tmpl escrito num diretório chamado 1.0.0 — é recusada, porque o nome do diretório não faz parte do que viaja: uma entidade publicada é lida a partir de um diretório cujo nome é dado pela cache do destinatário, onde esse nome não encontra nada. Um caminho que passa por uma ligação que conduz para fora é recusado porque, caso contrário, uma publicação transportaria os bytes para os quais a ligação aponta, de onde quer que aponte, sob um nome interno à entidade.
É recusado onde quer que a entidade seja lida. Um aggrega validate de todo o catálogo, aggrega validate sobre o ficheiro da própria entidade, aggrega pull e aggrega build recusam-no quando o ficheiro da entidade é lido, e o mesmo fazem aggrega pin de uma Recipe ou de uma FeatureRecipe e aggrega push de qualquer um dos quatro tipos, antes de qualquer coisa ser obtida, escrita ou publicada. Uma source: escrita como template não designa nada até a compilação a avaliar; por isso, um template que produz um caminho fora do diretório é recusado pela compilação, no momento em que o valor existe.
Uma Release é diferente, e uma referência a uma entidade também. Uma Release aponta para outras entidades — o seu Aggregate, o seu Manifest, a Release que estende — e nunca é publicada, pelo que nada do que lê viaja para lado nenhum: esses caminhos, e o ficheiro que os parameters: de uma Release importam, são lidos tal como estão escritos. O type de um Aggregate designa outra entidade pela sua identidade, e não por conteúdo que o Aggregate transporta, e também é resolvido nos seus próprios termos: através dos diretórios do catálogo, da cache e do registo, nunca como um caminho de ficheiro.
Mensagem emitida, que designa o caminho tal como está escrito:
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 (um caminho designa conteúdo fora do diretório da própria entidade. correção: mova o ficheiro para o diretório que contém a entidade, ou para um diretório abaixo dele, e designe-o com um caminho relativo a esse diretório. O conteúdo de uma entidade reside no diretório da própria entidade porque cada ficheiro que uma publicação dela transporta é obtido daí; um caminho que sai dele aponta para um ficheiro que não viajaria com a entidade)
e, para um caminho que uma ligação leva para fora do diretório, que designa a ligação e o local para onde conduz:
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 (um caminho designa conteúdo fora do diretório da própria entidade. correção: substitua a ligação por uma cópia daquilo para que conduz, colocada dentro do diretório que contém a entidade. O conteúdo de uma entidade reside no diretório da própria entidade porque cada ficheiro que uma publicação dela transporta é obtido daí; uma ligação que sai dele transportaria os bytes para os quais aponta sob um nome interno à entidade)
O campo a partir do qual foi lido é indicado na linha acima da mensagem: resolve Recipe source …, resolve Recipe artifact "<key>" $import target …, spec.schema.values: imported schema … ou, para uma origem gerada por template, node "<name>" source.
Como corrigir: mova o ficheiro para o diretório da entidade, ou para um diretório abaixo dele, e escreva o seu caminho relativamente a esse diretório. Onde uma ligação levar o caminho para fora, substitua a ligação por uma cópia daquilo para que conduz, dentro do diretório da entidade. Um chart partilhado por várias Recipes é copiado para o diretório de cada Recipe, uma vez que cada uma é publicada separadamente; um esquema partilhado por vários Components pertence a uma SchemaLibrary, que cada Component depois referencia pela sua identidade, e um corpo de mapping, de workload ou de artefacto partilhado por várias Recipes pertence ao tipo de biblioteca correspondente.
A Recipe’s source: names a kind nothing knows how to acquire (A origem de uma Recipe designa um tipo que nada sabe como adquirir)
A source: de uma Recipe indica para que tipo de coisa aponta — um chart, um módulo, um projeto compose — e cada tipo é adquirido pelo adaptador de origem que serve esse tipo. Esta condição reporta um tipo que nenhum adaptador de origem serve, pelo que nada do que este programa inclui consegue obter a origem. A source: de uma FeatureRecipe está sujeita à mesma regra.
É recusado quando o documento é lido, antes de qualquer coisa ser obtida: verificar a Recipe isoladamente recusa-o, e o mesmo faz cada Release que chega a ela. Nada foi tentado, porque nada o podia tentar — e é isso que o distingue de uma aquisição que foi executada e falhou.
Mensagem emitida, que designa o documento, o tipo tal como está escrito e os tipos servidos:
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 (nenhum adaptador de origem serve o tipo de origem (Recipe, regra source-kind). a origem designa um tipo; designe um tipo que um adaptador de origem sirva, ou escreva a origem como um único URI cuja forma designe o seu tipo)
Como corrigir: corrija o tipo na source: para um que a cadeia de ferramentas sirva — um erro ortográfico e um tipo que realmente não tem adaptador produzem a mesma mensagem, e a mensagem cita o tipo tal como foi escrito ao lado dos tipos servidos; por isso, a primeira coisa a verificar é a grafia face a essa lista, que a página da Recipe também descreve. Se o tipo estiver escrito como pretendido, esse tipo não é um que esta compilação consiga adquirir, e nenhuma alteração à Recipe o tornará possível; em vez disso, aponte a source: para uma forma servida, ou escreva-a como um único URI cuja forma designe o seu tipo.
No source adapter is registered in this program for a source kind (Nenhum adaptador de origem está registado neste programa para um tipo de origem)
Uma origem é obtida pelo adaptador registado para o seu tipo. Esta condição reporta uma obtenção despachada para um tipo para o qual nenhum adaptador está registado. Um tipo escrito pelo autor que nenhum adaptador serve é recusado quando a sua Recipe é lida (em «A Recipe’s source: names a kind nothing knows how to acquire (A origem de uma Recipe designa um tipo que nada sabe como adquirir)» acima), pelo que nada do que um autor escreve chega até aqui: reporta um programa montado sem o adaptador para um tipo que serve, ou um programa construído sobre os pacotes Go do Aggrega que despacha uma obtenção para um tipo que ele próprio montou.
Mensagem emitida, que designa o tipo:
kind "<kind>": no source adapter is registered in this program for the source kind (tipo: nenhum adaptador de origem está registado neste programa para o tipo de origem)
Como corrigir: nada nos ficheiros de entidade causa isto. Comunique-o a quem compilou o binário que está a executar.
A source URL carries a credential (Um URL de origem contém uma credencial)
O url de uma origem é registado tal como foi escrito — no ficheiro de bloqueio da Release, no entity.lock ao lado da Recipe e na cache de origens — e a própria Recipe é um ficheiro que se submete com commit e que se pode publicar. Assim, uma credencial escrita no URL viajaria para todo o lado onde o URL vai. Esta condição reporta uma source: de uma Recipe cujo url escreve um utilizador antes do host: https://user:token@host/…, ou um token escrito sozinho como https://token@host/…, uma vez que um serviço acedido por HTTP aceita habitualmente um token no lugar do utilizador. Em http e https, conta qualquer utilizador aí escrito; noutro esquema, só conta uma palavra-passe, porque um utilizador escrito sozinho aí designa uma conta — ssh://git@github.com/… é aceite, e o agente SSH fornece a sua chave. A source: de uma FeatureRecipe está sujeita à mesma regra.
É recusado quando o documento é lido, antes de qualquer coisa ser obtida: verificar a Recipe isoladamente recusa-o, e o mesmo faz cada Release que chega a ela, numa validação, num pull, num pin ou numa compilação. A mensagem designa o host e nunca a credencial. A verificação lê a parte do URL escrita antes do host e nada mais, pelo que um token transportado numa query string ou num caminho não é detetado — e é registado tal como está escrito, como o resto do URL.
Mensagem emitida em http ou https, que designa o documento, a chave e o host, e depois onde a credencial deve ficar:
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) (o URL de origem contém uma credencial (Recipe, regra source-url). spec.source.url designa um utilizador ou uma palavra-passe para o host; remova-os do URL e escreva antes a credencial no ficheiro netrc, como uma entrada «machine … login … password …» (o ficheiro que NETRC designa, caso contrário .netrc no diretório pessoal, ou _netrc em %USERPROFILE% no Windows))
e noutro esquema, onde a correção é remover a palavra-passe:
the source URL carries a credential (Recipe <name>:<version>, rule source-url, at <file>). spec.source.url names a password for host <host>; remove it from the URL, which is written into the lockfile and the cache as authored (o URL de origem contém uma credencial (Recipe, regra source-url). spec.source.url designa uma palavra-passe para o host; remova-a do URL, que é escrito no ficheiro de bloqueio e na cache tal como foi redigido)
Como corrigir: remova o utilizador e a palavra-passe do url, deixando o URL que designa o host. Para uma origem obtida por http ou https, coloque a credencial numa entrada machine para esse host no ficheiro netrc, que cada obtenção de um repositório clássico de charts Helm, de um fragmento compose ou de um repositório Git por HTTP ou HTTPS lê — Autenticação descreve que ficheiro e que entrada. Para um repositório Git por SSH, o agente SSH fornece a chave, e o utilizador pode manter-se. Se a Recipe já foi submetida com commit ou publicada com a credencial lá dentro, a credencial está nesse histórico: altere-a também no servidor.
A {{ .parameters.* }} reference cannot be interpolated (Uma referência a parâmetros não pode ser interpolada)
O texto do Aggregate é avaliado como um template antes de ser lido como um documento, para que uma referência {{ .parameters.<key> }} seja substituída pelo valor que a Release forneceu para ela. Esta interrupção ocorre quando essa avaliação não pode ser concluída: o texto não é analisado como template, ou é analisado e falha durante a execução.
A interpolação acontece antes de o Aggregate ser analisado como YAML, e é por isso que uma falha aqui é reportada relativamente ao Aggregate como um todo, e não numa chave dentro dele — nesse ponto o documento ainda não tem chaves. É também por isso que a referência pode ficar sem aspas: a substituição acontece nos bytes em bruto, e a própria regra de aspas do YAML decide depois o tipo do valor; assim, uma referência sem aspas produz o tipo natural do valor e uma entre aspas produz uma cadeia de caracteres.
Uma referência que designa uma chave que a Release não forneceu não é esta interrupção. Uma chave ausente resolve-se aqui num valor vazio e é intercetada, com o seu tipo e o seu contrato, pelas verificações de parâmetros descritas em «Parameter type mismatch / contract violation (Tipo de parâmetro incompatível / violação de contrato)» acima. O que esta interrupção reporta é um texto que o motor de templates não conseguiu processar de todo — um {{ não fechado, um nome de função mal escrito, um pipeline cujas fases não encaixam entre si. Ler um parâmetro através de index — {{ index .parameters "db_size" }} — quando a Release não forneceu esse parâmetro é uma falha durante a execução, e esta interrupção transporta-a, designando a chave: index interrompe perante uma chave de mapa que o mapa não contém em todas as superfícies de template, como descreve «A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)» abaixo.
Um texto que não é de todo analisado é recusado com o caminho do próprio Aggregate designado, porque esse ficheiro está disponível antes de qualquer coisa o ler. Um módulo que a composição importa é avaliado da mesma forma um nível abaixo, onde o seu texto é lido a partir do catálogo em vez de ser entregue à compilação. A interrupção é esta mesma condição e transporta este código em ambos os casos; para um módulo, designa também o import que estava a seguir e o ficheiro a partir do qual o texto do módulo foi lido, e a mensagem que transporta designa apenas o tipo — pelo que a posição que essa mensagem indica é uma posição no texto do próprio módulo, e não no Aggregate de onde se partiu.
Mensagens emitidas, para um template que não é analisado, para a mesma falha num módulo que a composição importa, e para um template que falha durante a execução:
invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate <path>, “template parse error: <underlying reason>”) (referência de parâmetro inválida: verifique se a expressão {{ .parameters.* }} designa um parâmetro declarado e é analisada como um template Go (Aggregate, «erro de análise do template»)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template parse error: <underlying reason>) (referência de parâmetro inválida: verifique se a expressão {{ .parameters.* }} designa um parâmetro declarado e é analisada como um template Go (Aggregate, erro de análise do template)) invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template (Aggregate, template execution error: <underlying reason>) (referência de parâmetro inválida: verifique se a expressão {{ .parameters.* }} designa um parâmetro declarado e é analisada como um template Go (Aggregate, erro de execução do template))
O texto de um Aggregate tem uma única raiz, .parameters, pelo que uma referência através de qualquer outra — {{ .values.app_token }} ou {{ $.values.app_token }} — não lê nada e falha durante a execução. O motivo começa então por designar a referência que leu:
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>) (referência de parâmetro inválida: verifique se a expressão {{ .parameters.* }} designa um parâmetro declarado e é analisada como um template Go (Aggregate, o template lê uma referência, e o texto de um Aggregate não define nenhuma raiz além de .parameters; erro de execução do template))
Como corrigir: abra o Aggregate e leia o motivo subjacente, que designa a posição no texto e a construção que falhou. Confirme que cada {{ tem o seu }}, que uma função chamada é uma das que a superfície oferece — a interpolação de parâmetros oferece as funções do Sprig e nada mais, pelo que a função auxiliar optionalnão está disponível aqui — e que as fases de um pipeline aceitam o que a fase anterior produz. Se o motivo designar uma chave que index não encontrou, leia um parâmetro que possa não estar definido com um ponto ({{ .parameters.db_size }}) ou através de get ou hasKey do Sprig. Se designar uma referência através de outra raiz, declare o valor como um parâmetro do Aggregate e leia-o como {{ .parameters.<key> }}. Se designar algo que nunca se pretendeu como template — undefined variable "$json" proveniente de uma expressão do n8n, ou uma função com o nome de um nó do Flowise — o texto contém chavetas duplas próprias, incluindo as de um comentário: escreva cada {{ nele como {{"{{"}}, como descreve Texto que contém as suas próprias chavetas duplas.
The Release directory declares one Aggregate or Manifest twice (O diretório da Release declara duas vezes um Aggregate ou um Manifest)
Uma Release cuja referência aggregate: ou manifest: é uma identidade simples é resolvida examinando primeiro o próprio diretório da Release, e esse exame encontrou dois Aggregates — ou dois Manifests — com o mesmo metadata.name. Uma referência por identidade simples designa uma entidade por esse nome, pelo que um nome reivindicado duas vezes é um nome pelo qual o diretório não pode responder.
O exame recusa o diretório no seu todo, e não apenas o nome que uma referência pediu. Lê cada Aggregate e cada Manifest que se encontra ao lado da Release, pelo que um par em colisão que nenhuma das duas referências designa também interrompe a compilação: o diretório é ambíguo, quer esta Release fosse ou não a que ia ler essa entidade. Uma referência escrita como caminho (./aggregate.yaml, ../shared/manifest.yaml) aponta para um ficheiro e não para uma entidade e é resolvida sem o exame, pelo que uma Release cujos aggregate: e manifest: são ambos caminhos nunca o executa.
Esta é a contrapartida, no mesmo diretório, da recusa por identidade duplicada do catálogo, e as duas são comunicadas separadamente para que a mensagem indique o diretório em que se encontra, e não um nível do catálogo em que talvez não estivesse a pensar.
Mensagem emitida:
duplicate Aggregate/Manifest identity (metadata.name) in the Release directory: Aggregate "<name>" declared more than once in <release-directory> (identidade Aggregate/Manifest duplicada (metadata.name) no diretório da Release: Aggregate declarado mais de uma vez)
com Manifest em vez de Aggregate quando colidem dois Manifests.
Como corrigir: atribua a uma das duas entidades um metadata.name diferente, ou retire-a do diretório da Release. Duas Releases que implementam de facto Aggregates diferentes com o mesmo nome pertencem a diretórios próprios; copiar uma Release para um ficheiro vizinho sem mudar o nome do que ela contém é a forma habitual de isto acontecer.
A Release’s aggregate: or manifest: reference resolves to nothing (A referência de uma Release não se resolve em nada)
Uma Release designa um Aggregate ou um Manifest por identidade simples e não foi encontrada nenhuma entidade com esse nome em nenhuma das superfícies em que uma identidade simples é procurada: o próprio diretório da Release, o catálogo e o registo.
Mensagem emitida, quando nada correspondeu em lado nenhum:
aggregate/manifest reference unresolvable: no Aggregate named "<reference>" in the Release directory, catalog, or registry (referência aggregate/manifest impossível de resolver: nenhum Aggregate com esse nome no diretório da Release, no catálogo ou no registo)
Um ficheiro no diretório da Release que não pôde ser indexado altera o relatório, porque altera o que pode ser afirmado com honestidade. Esse ficheiro poderia ter sido a entidade, pelo que a mensagem o diz em vez de afirmar uma ausência que não consegue estabelecer, e inclui a falha de análise que impediu a sua leitura:
aggregate/manifest reference unresolvable: Aggregate "<reference>" not found; unparseable file <path> could not be indexed and may be it: <parse failure> (referência aggregate/manifest impossível de resolver: Aggregate não encontrado; o ficheiro impossível de analisar não pôde ser indexado e pode ser esse)
e quando um ficheiro impossível de analisar é precisamente aquele que a referência designa:
aggregate/manifest reference unresolvable: needed Aggregate "<reference>" is the unparseable file <path>: <parse failure> (referência aggregate/manifest impossível de resolver: o Aggregate necessário é o ficheiro impossível de analisar)
Como corrigir: quando a referência está realmente ausente, corrija a sua grafia — a identidade é o metadata.name da entidade, não o nome do ficheiro — ou acrescente a entidade ao diretório da Release ou ao catálogo que a compilação lê. Quando a mensagem indica um ficheiro impossível de analisar, corrija primeiro esse ficheiro: a respetiva falha de análise é citada na mensagem, e repará-lo resolve muitas vezes a referência na mesma edição. Uma referência ./ ou ../ é um caminho e não uma identidade, e é resolvida como tal, pelo que um ponto inicial muda qual dos dois erros se está a procurar.
A component is placed in more than one boundary (Um componente está colocado em mais de uma fronteira)
A árvore de fronteiras de uma Release coloca um componente em duas fronteiras diferentes. As duas colocações não são fundidas nem hierarquizadas, nem poderiam ser: a fronteira de um componente decide onde a sua saída é escrita, em que subdiretório fica, a que sync wave se junta e que anotações e que infra de fronteira herda — enquanto a sua superfície uses: por aresta é lida por um percurso separado. Um componente indicado duas vezes iria buscar a localização da sua saída a uma colocação e a sua configuração por aresta à outra.
Uma fronteira coloca componentes de três formas, e as três contam. Indicar um diretamente sob components:, pelo id que tem depois de a composição estar concluída, coloca-o. Indicar um dentro do próprio components: de uma entrada de encaminhamento, pelo nome local que tem dentro desse submódulo, também o coloca. E encaminhar um submódulo inteiro sob aggregates: coloca cada componente que esse módulo contém. Assim, esta interrupção abrange também um submódulo encaminhado para duas fronteiras, um módulo encaminhado para uma fronteira com um módulo nele aninhado encaminhado para outra, e um componente indicado numa fronteira enquanto o módulo que o contém está encaminhado para uma fronteira diferente.
Encaminhar um módulo para uma fronteira e indicar também um dos seus componentes sob essa mesma fronteira não é um conflito — ambas as colocações concordam quanto ao lugar a que o componente pertence — e a compilação é concluída. Um mesmo id escrito duas vezes sob uma única fronteira é um conflito mesmo aí: uma entrada no components: da fronteira e uma entrada para esse mesmo componente dentro da entrada de encaminhamento da fronteira são duas entradas com configuração para um único componente, sem nada que permita escolher entre elas.
Cada colocação infratora é comunicada. Uma Release que coloca vários componentes duas vezes é interrompida com uma destas mensagens por cada entrada infratora numa única compilação, cada uma na chave da entrada a que se opõe — pelo que várias delas em conjunto são uma única compilação que indica tudo o que encontrou, e não uma única falha escrita mais de uma vez.
A colocação que uma mensagem indica como já em vigor nem sempre é a escrita primeiro no ficheiro. As próprias entradas components: de uma fronteira são lidas antes dos componentes que as suas entradas de encaminhamento indicam e antes dos submódulos que encaminha, e uma fronteira é lida antes das fronteiras nela aninhadas; as fronteiras escritas lado a lado são lidas pela ordem em que aparecem. Quando mais de uma colocação anterior entra em conflito, é indicada a primeira lida. Ambos os locais são indicados, seja qual for a ordem em que surjam, e nenhum é colocado acima do outro.
Mensagem emitida. A frase enuncia a regra; o que se segue indica a entrada infratora, a fronteira em que se encontra cada uma das duas colocações, o bloco em que cada uma foi escrita e o ficheiro que contém ambas. Quando uma entrada sob o components: de uma fronteira encontra uma entrada anterior sob o de outra fronteira:
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 em mais de uma fronteira: declare cada componente em exatamente uma fronteira (Release; indicado no bloco components de uma fronteira, quando já está indicado no bloco components de outra fronteira; ambos declarados no mesmo ficheiro))
As duas orações que indicam as fronteiras são redigidas de acordo com o bloco em que cada entrada foi escrita. A entrada infratora recebe uma das seguintes:
named in the components block of boundary "<boundary>" — o próprio mapa components: da fronteira;
named inside a routing entry in boundary "<boundary>" — o mapa components: de uma entrada de encaminhamento sob o aggregates: dessa fronteira;
routed as a sub-module into boundary "<boundary>" — a própria entrada de encaminhamento.
A colocação anterior, continuando a mesma frase, recebe uma das seguintes:
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>".
As duas orações são escolhidas de forma independente, pelo que pode surgir qualquer combinação delas, e that earlier entry naming contém aquilo a que essa colocação anterior se referia: o id do componente, ou o prefixo do submódulo quando foi um submódulo encaminhado que o colocou.
Quando a entrada infratora é ela própria uma entrada de encaminhamento, aquilo a que se refere é um submódulo e não um único componente, e a mensagem di-lo em vez de apresentar um prefixo de módulo como nome de componente — aqui ao encontrar um submódulo anterior encaminhado para outra fronteira:
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 em mais de uma fronteira: declare cada componente em exatamente uma fronteira (Release; submódulo encaminhado como submódulo para uma fronteira, quando já está colocado por um submódulo encaminhado para outra fronteira; ambos declarados no mesmo ficheiro))
Como corrigir: elimine aquela das duas colocações que não pretendia. A mensagem indica ambas, pelo que a escolha é sua e não do compilador. Quando uma declaração direta e um módulo encaminhado discordam, decida se o componente pertence ao seu módulo ou fica por conta própria: encaminhar o módulo coloca-o junto de tudo o resto que o módulo contém, e indicá-lo diretamente separa-o disso. Quando duas entradas de encaminhamento reivindicam um mesmo módulo, retire o encaminhamento que não pretendia — encaminhar um módulo para uma fronteira coloca lá cada componente que contém, pelo que duas entradas desse tipo reivindicam o mesmo conjunto de componentes.
A Manifest annotation binding claims the reserved aggrega.ai/ prefix (Uma associação de anotação do Manifest reivindica o prefixo reservado)
Um Manifest declara uma associação de anotação sob uma chave que começa pelo prefixo simples aggrega.ai/. Esse prefixo é onde a compilação aplica as chaves que ela própria emite, pelo que uma associação que reivindicasse uma chave dentro dele colocaria o seu encaminhamento e a saída própria da plataforma num único espaço de chaves, a competir pelos mesmos nomes.
A compilação é interrompida, e não poderia ser um aviso. A reserva é tudo o que torna esse espaço de chaves da plataforma; admitir a associação e mencioná-la depois deixaria a colisão na compilação.
A regra diz respeito ao espaço de chaves que uma associação escrita pelo autor reivindica, pelo que uma chave para a qual o Manifest apresentado não declara associação é ignorada em vez de comunicada — não há associação que possa estar em infração.
Mensagem emitida. A chave infratora vem primeiro, porque é dela que a frase trata, e cada um dos valores seguintes é introduzido por aquilo que é:
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>/") (a associação de anotação do manifest usa um prefixo reservado (Manifest; prefixo reservado; encaminhamento para uma Feature; escreva a associação sob um domínio próprio))
Como corrigir: mude o nome da chave da associação para um espaço de nomes que controle. Uma chave com subprefixo é a forma suportada e não está reservada: feature.aggrega.ai/… para um atalho da biblioteca-padrão, ou o seu próprio domínio — acme.aggrega.ai/…, compliance.example.com/… — para um atalho empresarial. Mudar o nome da chave altera o que um autor escreve num componente para acionar a associação, pelo que deve atualizar as anotações que a usam na mesma edição. As chaves próprias da plataforma sob o prefixo simples estão listadas em ../providers/well-known-annotations.md.
Two Manifest annotation bindings compete for one routing slot (Duas associações de anotação do Manifest competem por um mesmo slot de encaminhamento)
Duas associações de anotação num mesmo Manifest encaminham para a mesma Feature, através do mesmo pilar, no mesmo caminho. A função de uma associação é indicar onde vai parar o valor de uma anotação, e duas associações que indicam um único destino deixam o valor com duas rotas e nada que permita escolher entre elas no momento da expansão.
Apenas uma associação pode declarar um dado par caminho-pilar por Feature de destino. Duas associações que visam a mesma Feature em caminhos diferentes são autoria comum e a compilação é concluída; o mesmo acontece com duas associações que encaminham o mesmo caminho para duas Features diferentes.
As associações são percorridas pela ordem em que o Manifest as declara, pelo que a associação que uma mensagem indica primeiro é sempre a anterior no seu documento.
Mensagem emitida:
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) (as associações de anotação do manifest colidem no mesmo caminho+pilar da Feature (Manifest; ambas as associações de anotação visam a Feature com um caminho que encaminha para o pilar; apenas uma associação pode declarar um dado par (caminho, pilar) por Feature))
Como corrigir: decida qual associação é dona do destino e retire o caminho da lista maps.infra ou maps.values da outra, ou elimine por completo a segunda associação. Se as duas associações existem porque se pretendia que duas chaves de anotação chegassem a um único campo da Feature, mantenha uma associação e deixe ambas as chaves de anotação serem encaminhadas por ela; se existem porque dois valores diferentes deviam ir parar a dois lugares, corrija o caminho que foi escrito por engano.
A Release reached resolution without passing through the load path (Uma Release chegou à resolução sem passar pelo caminho de carregamento)
Uma Release chegou à resolução com uma superfície components: de nível superior não vazia e, ao mesmo tempo, uma fronteira default sintetizada. Essa combinação não pode ser produzida por uma Release carregada normalmente: o caminho de carregamento incorpora um bloco components: de nível superior na fronteira predefinida e esvazia-o, e um documento que escreveu ambos explicitamente é recusado pelo seu esquema antes de chegar tão longe.
Esta interrupção não comunica, portanto, nada do que escreveu. Comunica que algo chegou à resolução contornando o caminho de carregamento — na maioria dos casos, uma Release construída em memória por um programa que incorpora o compilador em vez de lida a partir de um ficheiro — e para aí em vez de deixar uma compilação prosseguir sobre um documento cujas duas superfícies de componentes discordam. Lê-las numa ordem ou na outra produziria uma saída que omite ou duplica componentes silenciosamente, e o percurso das fronteiras e o percurso por aresta nem sequer estariam de acordo entre si sobre quais.
Mensagem emitida:
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 (a Release chegou à resolução sem normalização (componentes raiz não vazios ao lado de uma fronteira predefinida sintetizada): construa as Releases através do núcleo de normalização (types.NormalizeRelease através do caminho de carregamento), não com um literal construído à mão)
Como corrigir: nada, se estiver a escrever YAML — chegar a esta interrupção a partir de aggrega build, aggrega validate ou do editor significa que o compilador tem um defeito que vale a pena comunicar, e a Release que estava a compilar não tem culpa. Se estiver a incorporar o compilador e a construir um valor Release no seu próprio código, construa-o através do caminho de carregamento em vez de montar a struct diretamente, para que seja executada a normalização que incorpora os componentes raiz na fronteira predefinida.
A library reference expands into itself (Uma referência de biblioteca expande-se em si mesma)
Uma cadeia de referências entre documentos regressa a um documento que já alcançou, pelo que expandi-la nunca terminaria. Duas superfícies de autoria chegam à mesma condição, e ambas são cadeias entre entidades de biblioteca e não algo dentro de um único ficheiro: um $ref: de um pilar de esquema para uma entrada de uma SchemaLibrary que, de referência em referência, regressa ao ponto de partida, e um $import: para uma entrada de uma MappingLibrary ou de uma WorkloadLibrary que faz o mesmo.
A cadeia é comparada com base numa chave canónica — a identidade da biblioteca e o nome da entrada, sem qualquer host de registo nem grafia de versão — para que um ciclo não possa escapar à verificação designando a mesma entrada de duas formas diferentes ao longo do seu percurso. Uma referência que se expande e termina não levanta problemas, por muitas vezes que apareça e por mais profunda que seja a cadeia; a profundidade, por si só, nunca causa esta interrupção, e reutilizar uma entrada de biblioteca a partir de muitos lugares é o padrão para o qual as bibliotecas existem.
Mensagem emitida, para uma cadeia $import:, que indica o ciclo completo pela ordem em que foi percorrido, para que se veja qual o passo que o fecha:
Uma cadeia $ref: é comunicada, em vez disso, pelo compilador da forma compacta, que a enquadra com o documento e a palavra-chave que estava a ler:
compactform at <consumer-file> (keyword "$ref"): circular cross-document $ref expansion: <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> -> <Library>#/schemas/<entry> (compactform, palavra-chave: expansão circular de $ref entre documentos)
Como corrigir: leia a cadeia na mensagem e quebre-a no passo que não era pretendido. Um ciclo significa normalmente que duas entradas de biblioteca foram escritas, cada uma, para estender a outra; reúna a parte comum numa terceira entrada a que ambas façam referência, ou incorpore-a numa delas. O último passo mostrado é o que fechou o ciclo, mas não é necessariamente o errado — a cadeia completa é impressa precisamente porque a escolha do elo a cortar é sua.
A mesma condição está também na base da recusa por recursão de âncora documentada acima em «YAML anchor aliased inside its own content (Âncora YAML referenciada por um alias dentro do seu próprio conteúdo)». Essa é um ciclo dentro do próprio texto de um único documento; esta é um ciclo entre documentos. A cadeia na mensagem distingue as duas num relance: um ciclo entre documentos indica entradas de biblioteca, e um ciclo dentro de um documento indica uma âncora.
A declared schema cannot be resolved (Um esquema declarado não pode ser resolvido)
Um esquema chegou ao ponto de ser usado para validar algo e não foi possível montá-lo como esquema. A causa mais comum é um $ref: que não designa nada que se possa resolver; um esquema que não satisfaz o metaesquema do JSON Schema chega à mesma interrupção, tal como um ramo then: ou else: sob uma palavra-chave condicional que não pode ser resolvido por si só.
A recusa acontece antes de qualquer validação contra o esquema, e essa ordem é o essencial. Ignorar um esquema ilegível deixaria sem validação tudo o que ele abrange enquanto a compilação comunicava sucesso — uma verificação que deixou de ser executada sem nada que diga que parou.
Mensagem emitida, que indica a posição dentro do esquema, a palavra-chave que não pôde ser resolvida e o que a resolução comunicou:
validator/jsonschema: schema resolution failed (at <path-inside-the-schema>, keyword "<keyword>", <what resolution reported>) (validator/jsonschema: falha na resolução do esquema (posição, palavra-chave))
Quando a falha está na raiz do esquema e não numa palavra-chave dentro dele, a posição e a palavra-chave são omitidas e a frase contém apenas o motivo comunicado.
Como corrigir: abra o esquema na posição que a mensagem indica. Um $ref: é o culpado habitual: confirme que o destino existe, que uma referência interna ao documento escreve exatamente o seu caminho #/$defs/… e que uma referência entre documentos designa uma entrada de SchemaLibrary que o fecho de dependências da compilação contém efetivamente. Quando a mensagem indica um ramo then: ou else:, esse ramo é um esquema de pleno direito e tem de poder ser resolvido por si só.
An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Não é possível avaliar um predicado)
Um esquema declara uma das duas palavras-chave de extensão cujo valor é um modelo, e o modelo não pôde ser utilizado: não é uma cadeia de caracteres, não é analisado como modelo, falhou durante a execução ou produziu algo diferente de true ou false.
x-aggrega-when: decide se um ramo condicional de um esquema se aplica; x-aggrega-validate: decide se um valor satisfaz uma regra que as próprias palavras-chave do esquema não conseguem exprimir. Ambas são lidas como veredictos, razão pela qual um resultado que não o seja é recusado em vez de interpretado: um predicado que produzisse uma cadeia vazia seria lido como falso e retiraria silenciosamente a regra que foi escrito para fazer cumprir.
Mensagem emitida:
validator/jsonschema: x-aggrega extension evaluation failed (at <path-inside-the-schema>, keyword "x-aggrega-validate", <what evaluation reported>) (validator/jsonschema: falha na avaliação da extensão x-aggrega)
com "x-aggrega-when" no lugar da palavra-chave quando é o predicado da condicional que está em erro, e o motivo comunicado a indicar o erro do modelo — uma posição de análise, uma função em falta ou o valor não booleano que o modelo produziu.
Como corrigir: abra o esquema na posição que a mensagem indica e leia o motivo comunicado. Confirme que o valor da palavra-chave é uma cadeia de caracteres, que o modelo é analisado e que cada caminho que percorre existe de facto no valor em validação — um predicado lê o valor como .value, e procurar qualquer outra coisa é o erro mais comum. Quando o motivo indica uma chave que index não encontrou, teste antes a chave com hasKey ou leia-a com get: index para numa chave que o mapa não contém, como descreve «A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)» mais adiante. Certifique-se de que o modelo termina a produzir true ou false: uma comparação fá-lo, ao passo que um modelo que se limita a produzir o valor não o faz.
A Workload does not satisfy the Workload schema (Um Workload não satisfaz o esquema Workload)
O bloco workload: de uma Recipe ou de uma FeatureRecipe foi lido e verificado face ao esquema Workload, e um ou mais campos não o satisfazem — uma chave mal escrita, um valor do tipo errado, um campo obrigatório omitido, um valor fora de um intervalo ou de uma enumeração declarados.
O relatório é agrupado: uma única interrupção contém todos os campos em erro, pelo que um Workload com quatro erros dá conta dos quatro numa só compilação em vez de um por compilação. O cabeçalho indica o Workload, a Recipe que o declara e o ficheiro; cada constatação abaixo dele indica o caminho do campo dentro do Workload, o que o esquema exigia nesse ponto e a correção, quando é possível indicá-la.
Mensagem emitida:
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> (falha na validação do workload (Workload na Recipe, fase do esquema))
Uma falha sem detalhe por campo — o bloco nem sequer pôde ser lido, em vez de ser lido e considerado insuficiente — contém, em vez disso, o motivo completo como única constatação.
Quando o modelo workload: lê um valor declarado sensível, nenhuma constatação cita um valor. Não é possível saber que campo do documento produzido veio desse valor, pelo que cada constatação cujo texto poderia conter um valor enuncia a restrição do esquema com <redacted> no lugar do valor, rematada por um aviso que indica o motivo, e não contém nenhuma correção derivada do 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)
Uma constatação que não cita nenhum valor — uma chave em falta, uma chave que o Workload não admite — lê-se como em qualquer outro modelo. Consulte vocabulary/compact-form-authoring.md «O que uma recusa diz sobre um valor declarado».
A compilação comunica a interrupção sob uma etiqueta CATALOG_ERROR, porque um bloco workload: é escrito pelo autor da Recipe e não pelo Aggregate nem pela Release.
Como corrigir: abra a Recipe nos caminhos de campo indicados e corrija cada um. Os caminhos são dados a partir da própria raiz do Workload, pelo que .containers.main.health.ready é o bloco ready sob a chave health do contentor main. Um contentor com nome é endereçado pela sua chave e um contentor de inicialização pela sua posição, razão pela qual os dois se leem de forma diferente. O que cada campo aceita encontra-se na referência de criação do Workload.
Um campo que o esquema pretende como texto, recusado porque o valor é um número ou um booleano, significa quase sempre uma expressão de modelo sem aspas. Um bloco workload: é processado antes de ser verificado, pelo que uma expressão escrita sem aspas se expande em texto simples e o YAML lê então esse texto como aquilo que parece. Uma quantidade de dimensionamento em núcleos inteiros, uma versão composta apenas por dígitos, uma porta e as palavras yes, no, on e off são todas lidas como algo diferente de texto. A constatação indica que tipo o YAML leu, e a solução é colocar a expressão entre aspas na Recipe — cpu: "{{ .infra.compute.cpu }}" em vez de cpu: {{ .infra.compute.cpu }} — para que o valor continue a ser texto, seja o que for que o operador forneça. Note-se que o valor do próprio operador não está em erro e que colocá-lo entre aspas na Release não altera nada: as aspas têm de estar na Recipe, à volta da expressão.
A Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Um anexo de Workload indica um slot que a entidade não declara, ou uma entrega que o slot proíbe)
Uma entrada attachments: de um contentor dentro de um bloco workload: faz referência a um slot de anexo, e a referência não corresponde aos slots que o Component ou a Feature declara no seu featuresSchema — ou, para uma entrada que indica uma ligação com connection:, aos slots que o socket dessa ligação declara. Uma entrada envFrom que indica uma ligação está sujeita às mesmas regras de ligação. A constatação indica qual destas formas se verifica.
O slot não está declarado. O from: da entrada indica um slot que o featuresSchema da entidade não contém — um erro ortográfico, ou um slot que foi renomeado apenas de um lado.
O slot é de caixa negra. O slot declara uma lista de permissões inject: vazia, que reserva a entrega à mecânica interna da própria Recipe. Um slot deste tipo é preenchido e consumido internamente, pelo que um Workload não lhe pode aceder.
A entrega está fora da lista de permissões do slot. O as: da entrada indica um mecanismo que a lista inject: do slot não permite.
A ligação não é uma das que o componente traça. O connection: da entrada indica um alias sob o qual não está escrita nenhuma ligação do componente.
O socket da ligação não declara o slot. O from: da entrada (ou, em envFrom, secret:) indica um slot que o socket através do qual essa ligação está cablada não declara.
O slot está escrito com o seu nome composto. O from: (ou secret:) da entrada é o nome que o anexo de uma ligação assume no componente — o alias, um ponto e o slot — escrito sem connection:. O slot de uma ligação só se alcança indicando a ligação.
Todas as entradas em erro de todos os contentores são comunicadas em conjunto, pelo que uma única compilação as indica todas. As constatações são agrupadas sob um único cabeçalho que indica o Workload, a sua Recipe e o ficheiro.
Mensagem emitida:
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> (falha na verificação cruzada do featuresSchema do workload (Workload na Recipe, fase featuresSchema): faz referência a um slot que não está declarado no featuresSchema do Component — declare o slot no featuresSchema do Component (ou da Feature), ou mude o nome da referência para um slot existente; o slot é de caixa negra (sem lista de permissões) e não pode ser referenciado a partir de uma entrada attachments de um Workload — os slots de caixa negra são entregues pela mecânica interna da Recipe; remova a referência do lado do Workload, ou alargue a lista de permissões inject do slot se se pretender a entrega do lado do Workload; o mecanismo de entrega não é permitido pelo slot (lista de permissões inject) — use um dos mecanismos de entrega permitidos, ou alargue a lista de permissões inject do slot no featuresSchema do Component/Feature; indica uma ligação para o slot, mas o componente não traça nenhuma ligação com esse alias — indique uma ligação que o componente trace, ou remova connection para ler um slot que o Component declara para os seus próprios anexos; indica um slot da ligação que o socket não declara — indique um slot que o socket declare, ou declare o slot no featuresSchema desse socket; indica o nome que o compilador compõe para um slot de uma ligação; um slot que o socket de uma ligação declara é designado indicando a ligação — escreva connection: ao lado de from:)
Numa entrada envFrom, as mesmas constatações encontram-se em .containers.<name>.envFrom[<i>].connection e .containers.<name>.envFrom[<i>].secret.
Como corrigir: cada constatação indica os dois lados, pelo que a escolha é qual dos lados alterar. Para um slot não declarado, corrija a grafia de from: ou declare o slot no featuresSchema da entidade — o sufixo .from do caminho do campo aponta para a referência. Para um slot de caixa negra, remova a referência do lado do Workload e deixe a Recipe entregar o material, a menos que a entrega do lado do Workload seja realmente pretendida, caso em que se deve dar ao slot uma lista de permissões inject:. Para um mecanismo recusado, mude as: para um dos que a lista de permissões indica, ou acrescente-lhe o seu. Para uma ligação que o componente não traça, corrija o alias para um dos que a constatação enumera, ou trace a ligação no Aggregate ou na Release. Para um slot que o socket não declara, indique um dos slots que a constatação enumera, ou declare o slot no featuresSchema do socket no Component. Para um nome composto, escreva a ligação e o slot separadamente, como mostra a constatação.
A Workload references a slot whose fill publishes no locator (Um Workload faz referência a um slot cujo preenchimento não publica nenhum localizador)
Uma entrada attachments: de um contentor indica um slot por referência, e o anexo que preenche esse slot não publica as chaves provides que tal referência lê. Fazer referência a um slot pelo nome significa pedir que o recurso que ele representa seja endereçado na saída produzida — pelo nome do recurso e pelo campo dentro dele. Um preenchimento que não publica nenhum dos dois não tem nenhum localizador para onde apontar, pelo que a referência não pode ser transformada em nada.
As chaves exigidas dependem da entrada, e a constatação indica quais esperava. Uma entrada que indica a sua própria key: fornece ela mesma o campo, pelo que apenas o name do recurso tem de ser publicado — e é isso que lhe permite fazer referência a um recurso com várias chaves. Uma entrada que não indica nenhuma key: lê o único campo publicado do slot, pelo que tanto name como key têm de estar presentes.
A verificação lê apenas se as chaves estão presentes; nunca inspeciona os seus valores. Todas as entradas em erro são comunicadas em conjunto, sob um único cabeçalho.
Mensagem emitida:
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 (o slot de anexo do workload não é referenciável (Workload na Recipe, fase slotReferenceability): o slot não é referenciável: os seus provides resolvidos não expõem a chave (uma referência de anexo do workload lê as chaves provides name e key) — faça referência a um slot preenchido por um anexo cujo schema.provides declare as chaves que esta referência lê, ou entregue-o através do canal inject do slot em vez de uma referência do workload)
Como corrigir: duas direções, e a certa depende do que se pretendia. Quando a referência está correta, o que tem de mudar é o anexo que preenche o slot: anexe uma Feature cujo schema.provides declare name — e key, quando a entrada não indica uma própria — para que exista um localizador para onde apontar. Quando o material nunca se destinou a ser endereçado pelo nome na saída, remova a referência e entregue-o antes através do canal inject: do slot, que transporta o valor em vez de um ponteiro para o local onde ele se encontra.
A container gives one environment variable two values (Um contentor dá dois valores a uma mesma variável de ambiente)
Um contentor de um bloco workload: nomeia a mesma variável de ambiente duas vezes: uma vez como chave das suas variables e outra como chave de uma entrada attachments entregue as: env. São verificados tanto um contentor principal como um contentor de inicialização, por igual no Workload que a Recipe de um componente renderiza e no Workload que uma FeatureRecipe renderiza — a anexada a um componente e a declarada numa fronteira — e a verificação lê o Workload tal como o seu template o renderizou.
Porque é que a compilação para em vez de escolher um. O ambiente de um contentor é escrito a partir dessas duas coleções numa ordem fixa — os fornecedores helm e compose escrevem primeiro cada entrada lida de um anexo e depois as variables simples. Um nome escrito das duas formas chegaria, portanto, ao processo com o valor que essa ordem deixar prevalecer, o que é consequência do sítio onde os dois tipos acabam e não de algo que tenha sido escrito, pelo que a compilação recusa o par em vez de o renderizar. A verificação é executada uma única vez, seja qual for o fornecedor que renderiza o Workload, depois das restantes verificações do Workload e antes de as entradas artifacts: serem avaliadas ou de o Workload ser entregue a qualquer fornecedor, pelo que um par recusado nunca é renderizado. Uma entrada attachments entregue as: file é montada como ficheiro em vez de ser definida no ambiente, pelo que nunca forma um par.
A verificação compara apenas nomes; nunca lê um valor, pelo que nenhuma constatação cita um. Dois tipos de entrada de ambiente ficam fora do que compara: uma entrada envFrom define as chaves do ConfigMap ou do Secret que nomeia, que não são conhecidas quando a compilação é executada, e uma entrada que um passo do pipeline escreve num documento renderizado não faz parte do Workload que a verificação lê.
Cada par é uma constatação própria, posicionada na chave workload: da Recipe ou FeatureRecipe que declara o Workload, e nomeia a variável e o contentor — um contentor principal pela sua chave, um contentor de inicialização pela sua posição na lista initContainers. As constatações chegam primeiro para os contentores principais, pela ordem em que foram escritos, depois para os contentores de inicialização por posição e, dentro de um contentor, pela ordem em que as suas entradas attachments foram escritas.
Mensagem emitida, para um par num contentor principal do Workload de uma Recipe. A categoria e o código curto desta condição, E0345, surgem no cabeçalho entre parênteses retos, e a posição lê-se <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 (um contentor declara uma mesma variável de ambiente duas vezes. Mude o nome de uma das duas ou escreva-as sob condições de template complementares para que apenas uma delas seja renderizada)
Um par num contentor de inicialização nomeia antes a sua posição na lista — init container "initContainers[<i>]" — e a constatação de uma FeatureRecipe nomeia, depois do contentor, o anexo que a liga, attachment "<attachment>", porque um componente pode ter vários anexos cujas FeatureRecipes são documentos separados.
Quando um Workload tem vários pares, as constatações são agrupadas sob uma linha que nomeia o documento: containers of the Workload this Recipe renders name one environment variable twice ou, para uma FeatureRecipe, containers of the Workload rendered by the FeatureRecipe that attachment "<attachment>" binds name one environment variable twice.
A compilação comunica a interrupção sob uma etiqueta CATALOG_ERROR, porque um bloco workload: é escrito pelo autor da Recipe ou da FeatureRecipe e não pelo Aggregate nem pela Release.
Como corrigir: decida qual das duas o contentor deve receber. Se ambas forem pretendidas, mude o nome de uma delas, para que o processo veja duas variáveis. Se forem alternativas — um valor de recurso simples para quando nenhuma credencial está anexada, por exemplo — proteja-as com condições complementares para que exatamente uma seja renderizada: escreva a variável sob {{ if not (hasKey (default dict .features) "<slot>") }} e a entrada attachments sob {{ if hasKey (default dict .features) "<slot>" }}, ou sob os dois ramos de um mesmo {{ if }}/{{ else }}. Um par protegido desta forma nunca chega à verificação, porque apenas uma das duas está no Workload renderizado.
A Release’s parameters: block is written in neither of its two shapes (O bloco de parâmetros de uma Release não está escrito em nenhuma das suas duas formas)
Uma Release satisfaz os parâmetros que um Aggregate declarou de uma de duas maneiras, e o bloco é lido pela sua forma. Ou é um mapeamento de nomes de parâmetros para valores escritos no próprio local, ou é um mapeamento de exatamente uma chave, $import:, cujo valor é o caminho de um ficheiro YAML que contém esses valores. Um bloco que não é nenhum dos dois é recusado na leitura, antes de qualquer coisa comparar os valores com as declarações do Aggregate.
São recusadas três formas. Um valor parameters: que não é de todo um mapeamento — um escalar ou uma lista. Um mapeamento que traz $import: ao lado de outras chaves, o que pede ao mesmo tempo os valores importados e os escritos e não dá nenhuma regra para os combinar. E um $import: cujo valor não é uma cadeia simples, que portanto não nomeia nenhum ficheiro.
O schema da Release declara as mesmas duas formas, pelo que um ficheiro de Release que traga qualquer uma das três encontra primeiro a verificação do envelope do documento, sob E0215, que experimenta as duas formas e indica porque é que cada uma falhou — aqui para uma 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 (falha na validação do envelope do documento (Release); spec.parameters: nenhum ramo oneOf corresponde (2 ramos experimentados): branch[0]: type: esperado object, obtido array; branch[1]: type: esperado object, obtido array. corrija o documento para que corresponda ao schema do seu tipo)
Para $import: ao lado de outra chave, o segundo ramo termina com additionalProperties: unexpected property: "<key>", e para um $import: escrito como lista em vez de cadeia termina com validation: type: array has type "array", want "string".
Mensagem emitida quando o valor não é um mapeamento, nomeando o que lá foi escrito — a list, por exemplo:
parameters: shape must be an inline object or {$import: }: line <line>: <shape> is written where a map is expected (parameters: a forma deve ser um objeto inline ou {$import: caminho local}: na linha indicada há um valor escrito onde se espera um mapeamento)
e quando $import: partilha o mapeamento com outra coisa, ou nomeia algo que não é um caminho:
parameters: shape must be an inline object or {$import: }: $import: must be the only key (got <n> keys) at line <line> (parameters: a forma deve ser um objeto inline ou {$import: caminho local}: $import tem de ser a única chave, foram encontradas várias chaves na linha indicada) parameters: shape must be an inline object or {$import: }: $import value must be a string scalar at line <line> (parameters: a forma deve ser um objeto inline ou {$import: caminho local}: o valor de $import tem de ser um escalar de cadeia na linha indicada)
Como corrigir: abra a Release na linha que a mensagem indica. Escreva os valores no próprio local sob parameters:, ou substitua o bloco inteiro por uma única entrada $import: cujo valor seja um caminho entre aspas. Se se pretendiam valores escritos e um ficheiro importado de valores predefinidos partilhados, mova os escritos para uma Release que, com extends:, estenda a que contém a importação — sobrepor várias fontes de parâmetros é precisamente a função de uma cadeia extends:, e esta única chave é lida de uma só fonte por conceção.
An inline-or-import field is written in neither shape (Um campo inline ou de importação não está escrito em nenhuma das duas formas)
Três campos que uma Recipe ou FeatureRecipe escreve — uma entrada artifacts.<name>:, um valuesMapping: e um workload: — aceitam as mesmas duas formas. Ou o corpo é escrito no próprio local, como escalar de cadeia (um bloco | é a grafia habitual para qualquer coisa com várias linhas), ou o valor é um mapeamento de exatamente uma chave, $import:, que nomeia antes o sítio onde o corpo está. O que um $import: pode nomear varia consoante o campo: uma entrada de artifacts importa um caminho local ou um bundle de uma ArtifactLibrary, enquanto valuesMapping: e workload: importam um caminho local ou uma entrada de uma biblioteca por identidade.
Um único leitor verifica os três, pelo que as recusas são as mesmas três seja qual for o campo em erro: um mapeamento que traz mais de uma chave, um mapeamento cuja única chave não é $import e um $import: cujo valor não é uma cadeia simples. Um valor que não é nem um escalar nem um mapeamento — na maior parte das vezes, uma lista — é recusado apenas pela sua forma.
Os schemas de Recipe e FeatureRecipe declaram as mesmas duas formas para cada um dos três campos, pelo que um ficheiro que traga qualquer um destes casos encontra primeiro a verificação do envelope do documento, sob E0215, que nomeia o campo e indica porque é que cada forma falhou — o primeiro ramo é a forma escrita no próprio local, o segundo a 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 (falha na validação do envelope do documento (Recipe); spec.artifacts: nenhum ramo oneOf corresponde (2 ramos experimentados): branch[0]: validação: type: object tem o tipo «object», esperado «string»; branch[1]: additionalProperties: propriedade inesperada. corrija o documento para que corresponda ao schema do seu tipo)
Isso é um mapeamento que traz uma chave ao lado de $import:. Uma única chave que não é $import termina com required: missing required property: $import, additionalProperties: unexpected property: "<key>", uma lista termina com type: expected object, got array, e um $import: que não é uma cadeia nomeia o tipo encontrado onde se esperava uma cadeia, como em type: array has type "array", want "string".
Mensagens emitidas. Cada uma começa com a frase do campo em erro e depois indica o que o leitor encontrou e onde:
artifacts entry: shape must be a string scalar or {$import: }: got <n> keys at line <line> (entrada de artifacts: a forma deve ser um escalar de cadeia ou {$import: caminho local}: foram encontradas várias chaves na linha indicada) valuesmapping: shape must be a string scalar or {$import: }: got key "<key>" at line <line> (valuesmapping: a forma deve ser um escalar de cadeia ou {$import: caminho ou identidade de biblioteca}: foi encontrada outra chave na linha indicada) workload: shape must be a string scalar or {$import: }: $import value must be a string scalar at line <line> (workload: a forma deve ser um escalar de cadeia ou {$import: caminho ou identidade de biblioteca}: o valor de $import tem de ser um escalar de cadeia na linha indicada)
Qualquer um dos três campos pode comunicar qualquer um desses finais; um valor que não tem nenhuma das duas formas termina com line <line>: <shape> is written where text or a map is expected, nomeando o que foi escrito — na maior parte das vezes, a list.
Como corrigir: abra a entidade na linha que a mensagem indica. Escreva o corpo no próprio local como escalar de bloco, ou substitua o valor inteiro por uma única entrada $import:. Um mapeamento que traz $import: e qualquer outra coisa não é nenhuma das duas formas — mova as chaves adicionais para dentro do ficheiro importado, ou escreva o corpo no próprio local. Um $import mal escrito — na maior parte das vezes, falta o $ — é lido como uma chave comum e comunicado como a única chave que não é $import.
A reference to a library entry carries whitespace (Uma referência a uma entrada de biblioteca contém espaços em branco)
Uma referência que nomeia uma entrada dentro de uma biblioteca escreve-se como um único token ininterrupto: a biblioteca, uma versão mínima :<version> opcional, depois # e o caminho da entrada — BaseWorkloads:1.0.0#/workloads/StatelessService. Nenhuma parte dela admite espaços em branco. Os nomes de biblioteca e os nomes de entrada estão ambos restringidos pelos schemas de biblioteca a grafias de identificador, e uma versão é uma versão, pelo que um espaço, uma tabulação ou uma quebra de linha em qualquer ponto de uma referência não pertence a nenhuma das três partes.
A recusa abrange todas as superfícies que endereçam uma entrada de biblioteca por identidade: um valuesMapping:, um workload: e uma entrada artifacts.<name>: escritos como $import:, e um $ref: de schema. Um caminho local escrito como $import: não traz # e não é uma referência a uma entrada de biblioteca, pelo que um caminho com um espaço não é afetado.
O que justifica recusar em vez de arrumar é que a parte inicial de um valor assim costuma ser uma referência por direito próprio. Cortar no espaço em branco resolveria essa referência e descartaria discretamente o resto do que o autor escreveu — e as duas metades de uma compilação não têm de descartar a mesma quantidade, pelo que uma poderia registar uma dependência que a outra nunca viu. Recusar garante que o valor significa uma única coisa.
A recusa é comunicada na linha do documento de onde a referência foi lida:
library reference: a reference to a library entry carries no whitespace or line break: $import target "<reference>" at line <line> (referência de biblioteca: uma referência a uma entrada de biblioteca não contém espaços em branco nem quebras de linha: destino de $import na linha indicada)
Uma referência chega a uma compilação por mais um sítio: o corpo de uma entrada de biblioteca que uma compilação já resolveu, em que um $import: na raiz do campo, na primeira linha, aponta para a entrada de outra biblioteca. Essa referência nunca foi lida de um documento que a compilação tenha aberto, pelo que é comunicada sem linha:
library reference: a reference to a library entry carries no whitespace or line break: "<reference>" (referência de biblioteca: uma referência a uma entrada de biblioteca não contém espaços em branco nem quebras de linha)
Como corrigir: abra a entidade na linha que a mensagem indica e junte a referência para que seja um único token. Uma quebra de linha antes do # é a causa habitual — uma referência partida em duas linhas para caber numa coluna é um único valor para o YAML e uma referência inválida aqui, pelo que deve ser escrita numa só linha, por mais longa que fique. A outra é um espaço final antes da aspa de fecho: fica dentro da versão mínima, onde nomeia uma versão que nenhum artefacto publicado tem. Na segunda forma, a referência está dentro da biblioteca nomeada imediatamente antes dela na mensagem; corrija-a onde essa biblioteca declara a entrada.
A library entry’s body is not the shape that library holds (O corpo de uma entrada de biblioteca não tem a forma que essa biblioteca contém)
Uma biblioteca publica corpos com nome para outras entidades importarem, e cada tipo de biblioteca contém uma única forma. Uma entrada de MappingLibrary e uma entrada de WorkloadLibrary contêm cada uma um corpo de template, pelo que o valor da entrada é um escalar — na prática, um bloco |. Uma entrada de ArtifactLibrary contém um bundle: os ficheiros que pertencem juntos a um mesmo nome, pelo que a entrada é um mapeamento do nome do ficheiro de saída para o corpo desse ficheiro, e cada corpo sob ela é um escalar.
Os corpos são capturados exatamente como foram escritos e não são analisados quando a biblioteca é carregada. O template contido num corpo é analisado onde é importado, e é por isso que aqui se verifica apenas a forma — um corpo que não é de todo um template carrega-se sem queixas e falha no ponto em que algo o renderiza.
Mensagens emitidas, cada uma a nomear a linha e o que lá foi escrito — a list, por exemplo:
mappinglibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (mappinglibrary: o corpo da entrada tem de ser um escalar de cadeia: na linha indicada há um valor escrito onde se espera texto) workloadlibrary: entry body must be a string scalar: line <line>: <shape> is written where text is expected (workloadlibrary: o corpo da entrada tem de ser um escalar de cadeia: na linha indicada há um valor escrito onde 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: a entrada tem de ser um mapeamento do nome de ficheiro para um corpo de cadeia: na linha indicada há um valor escrito onde se espera um mapeamento)
e, para um bundle cuja entrada é um mapeamento mas um de cujos ficheiros não é um escalar, nomeando o ficheiro:
artifactlibrary: entry must be a mapping of filename to a string body: file "<filename>": line <line>: <shape> is written where text is expected (artifactlibrary: a entrada tem de ser um mapeamento do nome de ficheiro para um corpo de cadeia: no ficheiro e na linha indicados há um valor escrito onde se espera texto)
A compilação comunica estes erros sob uma etiqueta CATALOG_ERROR que nomeia o ficheiro que estava a ler, com a frase acima por baixo.
Como corrigir: escreva o corpo como escalar de bloco sob a sua chave. Um corpo cuja primeira linha parece uma chave YAML — o que costuma acontecer com um template que produz YAML — é lido como um mapeamento aninhado se o escalar de bloco não estiver lá, e essa é a causa comum. Para uma ArtifactLibrary, escreva uma chave por nome de ficheiro de saída, com cada corpo como escalar de bloco próprio; um bundle escrito como um único corpo é o outro erro de forma comum.
A $instantiate: reference cannot be resolved (Não é possível resolver uma referência)
Uma SchemaLibrary pode declarar estruturas reutilizáveis em spec.templates, cada uma com os seus próprios $params, e uma entrada de esquema instancia depois uma delas, nomeando-a em $instantiate: e fornecendo os seus parâmetros em $args:. A substituição é literal: um escalar $<name> no corpo do modelo é substituído pelo valor do argumento. Não há avaliação de expressões, nem condicionais, nem ciclos, e um valor substituído é inserido tal como está, em vez de ser analisado à procura de outros marcadores.
Três defeitos levam à recusa da instanciação. O nome em $instantiate: não é um dos que a biblioteca declara. Um parâmetro que o modelo declara sem um default: não tem nenhuma entrada em $args:. Ou o valor de um argumento não é do tipo que o seu parâmetro declara — e uma chave de $args: que não nomeia nenhum parâmetro declarado é reportada da mesma forma, em vez de ser ignorada, pelo que um nome de argumento mal escrito é uma recusa e não um parâmetro que assume silenciosamente o valor predefinido.
Mensagens emitidas:
schemalibrary: template not found: "<template-name>" not declared in spec.templates (schemalibrary: modelo não encontrado: não declarado em spec.templates) schemalibrary: template parameter missing: "<parameter-name>" (template "<template-name>") (schemalibrary: parâmetro do modelo em falta) schemalibrary: template parameter type mismatch: <what the type check found> (schemalibrary: tipo do parâmetro do modelo incompatível) schemalibrary: template parameter type mismatch: argument "<argument-name>" is not declared in template "<template-name>"’s $params (schemalibrary: tipo do parâmetro do modelo incompatível: o argumento não está declarado nos $params do modelo)
Como corrigir: para um modelo não encontrado, corrija o nome para um que a biblioteca declare em spec.templates — e verifique se está a importar a biblioteca pretendida. Para um parâmetro em falta, adicione-o a $args:, ou atribua ao parâmetro um default: no modelo, para que quem o chama o possa omitir. Para uma incompatibilidade de tipo, altere o argumento para o tipo declarado ou alargue o type: do parâmetro; quando a mensagem nomeia um argumento não declarado, corrija a sua grafia ou remova-o.
A schema uses a JSON Schema keyword the library does not admit (Um esquema usa uma palavra-chave de JSON Schema que a biblioteca não admite)
$dynamicAnchor e $dynamicRef não são admitidos no conteúdo de uma SchemaLibrary. Adiam a decisão sobre o esquema para o qual uma referência é resolvida até ao momento em que o valor é validado, o que faz o significado de uma entrada de biblioteca depender do sítio de onde foi importada e não daquilo que diz — e o compilador resolve as estruturas de uma biblioteca antes de qualquer validação, pelo que não há nada contra o qual uma referência adiada possa ser resolvida.
A recusa é aplicada em três pontos, que em conjunto fecham os dois caminhos pelos quais a palavra-chave poderia chegar. Uma entrada de esquema é analisada quando a biblioteca é carregada. O corpo de um modelo é analisado quando a biblioteca é carregada, pelo que um modelo que contenha literalmente a palavra-chave falha nesse ponto e não na primeira compilação que o instancie. E o corpo substituído é analisado novamente após uma instanciação, pelo que fornecer a palavra-chave como valor de um argumento não passa as duas primeiras verificações.
Mensagem emitida:
schemalibrary: forbidden JSON Schema keyword: "$dynamicRef" at line <line> (schemalibrary: palavra-chave de JSON Schema proibida, na linha indicada)
Como corrigir: substitua a referência adiada por um $ref que nomeie diretamente uma entrada de $defs. Onde a estrutura varia realmente de uso para uso, exprima a variação como um modelo com $params e instancie-o em cada uso — é essa a substituição que esta superfície oferece, e é resolvida antes de qualquer validação contra o resultado.
A document nests deeper than the reader will descend (Um documento aninha-se mais fundo do que o leitor desce)
Cada mapeamento escrito pelo autor é lido para uma estrutura que preserva a ordem em que as suas chaves foram escritas, porque essa ordem chega ao resultado renderizado e faz parte do que torna uma compilação idêntica byte a byte entre execuções. Esse leitor desce um número limitado de níveis — cem — e recusa-se a ir mais fundo, pelo que uma entrada que, de outro modo, esgotaria a própria pilha do leitor é reportada como a recusa que é.
Mensagem emitida:
a document nests too many levels deep: it is read at most 100 levels deep (um documento aninha-se em níveis a mais: é lido até um máximo de 100 níveis de profundidade)
Como corrigir: os documentos realmente escritos por um autor aninham-se em poucos níveis, pelo que um documento que chega a cem é gerado, traduzido automaticamente ou acidentalmente autorreferencial. Procure um valor que se tenha expandido em si próprio — uma âncora YAML que referencia o conteúdo dentro do qual se encontra é recusada pela sua própria interrupção mais acima, mas um gerador que emite repetidamente a mesma estrutura não é. Onde a profundidade é real, extraia o ramo profundo para uma entidade própria e referencie-a pelo nome.
A provider declares a well-known annotation at a scope it does not render (Um fornecedor declara uma anotação well-known num âmbito que não renderiza)
Um Plugin que serve um fornecedor diz duas coisas sobre si próprio que têm de concordar. Em spec.provider.wellKnownAnnotations lista as anotações sobre as quais atua, cada uma com os âmbitos em que as lê. Em contract.inputKinds indica que tipos de entrada renderiza. Uma chave declarada num âmbito cujo tipo de entrada a mesma entidade não reivindica significa que essas duas afirmações se contradizem num único ficheiro, pelo que a entidade é recusada ao ser carregada.
A verificação é uma comparação da entidade consigo própria, e é por isso que não precisa de nenhum binário do plugin e é acionada onde quer que a entidade seja lida — incluindo um percurso do catálogo numa máquina que nunca obteve o artefacto.
Duas entradas não são comparadas, deliberadamente. Uma entrada com âmbito de fronteira não nomeia nenhum tipo de entrada, porque é resolvida uma única vez para uma fronteira inteira e não no caminho de renderização de um nó específico. Uma entrada que não declara âmbito nenhum não faz nenhuma afirmação por caminho: diz apenas que o plugin lê a chave algures.
O que a recusa não estabelece é que uma declaração que se mantenha seja verdadeira. Nada pode provar que o plugin que serve um fornecedor lê uma chave que diz ler; o que uma comparação de dois campos escritos pelo autor pode fazer é recusar o par que não pode ser verdadeiro nos dois termos. Uma chave declarada num âmbito que o fornecedor de facto renderiza, cujo plugin não lê nada aí, passa aqui.
Mensagem emitida:
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 (o fornecedor declara uma anotação well-known num âmbito, mas o seu contract.inputKinds não está reivindicado; declare a chave apenas num âmbito que o fornecedor renderize, ou reivindique o tipo de entrada: wellKnownAnnotations: uma chave está declarada num âmbito que o contrato do fornecedor não renderiza)
Como corrigir: a mensagem nomeia as duas metades. Retire esse âmbito da lista scope: da anotação, deixando os âmbitos que o fornecedor de facto renderiza, ou reivindique o tipo de entrada em contract.inputKinds se o fornecedor de facto o renderizar.
A compact-form schema uses a keyword the compact form does not know (Um esquema em forma compacta usa uma palavra-chave que a forma compacta não conhece)
Um esquema escrito na forma compacta contém uma chave que não é nem uma palavra-chave da forma compacta, nem uma das palavras-chave de JSON Schema que a forma deixa passar, nem um dos três marcadores que a forma reserva — $jsonschema:, $mode: e $ref:. As chaves desconhecidas são recusadas na leitura do esquema em vez de serem descartadas, porque uma restrição mal escrita que é ignorada não se torna restrição nenhuma, e um esquema que parece aplicado e não aplica nada é pior do que um que falha.
A recusa surge onde quer que um esquema seja compilado. As entradas de uma SchemaLibrary são compiladas quando o catálogo é carregado; o spec.schema de um Component, os seus valueSchema e infraSchema por socket, e os esquemas que uma Feature e um Plugin fornecedor declaram são compilados quando o catálogo é lido. O spec.schema de um Component ou de uma Feature reporta esta condição por si próprio, nomeando a entidade e o campo; o valueSchema ou o infraSchema de um socket reporta-a dentro de «A declared schema contract cannot be read as a schema (Um contrato de esquema declarado não pode ser lido como esquema)» mais abaixo, com a frase aqui citada como detalhe.
A própria frase do compilador da forma compacta nomeia a posição dentro do esquema, a linha de origem e a chave que não reconheceu:
compactform at <path-inside-the-schema>:<line> (keyword "<key>"): unknown keyword (compactform: palavra-chave desconhecida)
Uma chave escrita ao lado de um $ref: entre documentos é reportada sob a mesma condição, com uma frase própria, porque apenas três chaves irmãs podem acompanhar uma referência desse tipo:
compactform at <path-inside-the-schema>:<line> (keyword "<key>"): cross-document $ref sibling not allowed (allowed: properties, required, description) (compactform: chave irmã de um $ref entre documentos não permitida (permitidas: properties, required, description))
e, quando essa chave irmã pedia para reabrir a estrutura fundida, a frase indica em vez disso a maneira de o fazer:
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: chave irmã de um $ref entre documentos não permitida (permitidas: properties, required, description); use $jsonschema: para incorporar um esquema de objeto aberto se a estrutura fundida tiver de aceitar propriedades arbitrárias)
A condição sob a qual é registada é compactform: unknown keyword, que é aquilo para que o seu código curto é resolvido.
Como corrigir: corrija a chave na posição que a frase nomeia, de acordo com o vocabulário de palavras-chave em compact-form-authoring.md — um erro ortográfico é a causa mais comum. Onde a estrutura precisa realmente de uma palavra-chave de JSON Schema que a forma compacta não contém, escreva esse fragmento em $jsonschema:, que incorpora JSON Schema literalmente. Ao lado de uma referência entre documentos, mantenha apenas properties:, required: e description:; tudo o resto pertence à entrada de biblioteca para a qual a referência aponta.
A compact-form schema declares a field literally named type (Um esquema em forma compacta declara um campo chamado literalmente assim)
A forma compacta decide o que um mapeamento significa a partir da estrutura do seu conteúdo: uma chave type: marca uma folha de restrição, as palavras-chave estruturais de JSON Schema marcam um fragmento a deixar passar, e um mapeamento de nomes simples marca um objeto cujos filhos são esquemas. Um esquema que declara um campo chamadotype é a única estrutura que essas leituras não conseguem distinguir — parece uma folha de restrição e pretende ser um objeto com um único campo —, pelo que a forma pede ao autor que diga qual, com uma chave $mode: definida como compact ou jsonschema.
Esta condição é o que um $mode: escrito com qualquer outro valor reporta. O marcador existe para resolver a ambiguidade, pelo que um valor que não resolve nada é recusado em vez de adivinhado.
A própria frase do compilador da forma compacta:
compactform at <path-inside-the-schema>:<line> (keyword "$mode"): value must be compact or jsonschema (compactform: o valor tem de ser um dos dois indicados)
A condição sob a qual é registada é compactform: ambiguous dispatch — $mode required, que é aquilo para que o seu código curto é resolvido.
Como corrigir: defina $mode: compact onde o mapeamento é um objeto em forma compacta cujos campos por acaso incluem um chamado type, ou $mode: jsonschema onde o mapeamento é um fragmento de JSON Schema a tomar tal como está escrito. Onde nenhuma das duas leituras era a pretendida, mudar o nome do campo elimina a ambiguidade sem marcador nenhum.
A $jsonschema: escape carries content that is not a schema (Um escape contém um conteúdo que não é um esquema)
A chave $jsonschema: incorpora literalmente um fragmento de JSON Schema, para estruturas que a forma compacta não exprime. O que incorpora é tomado tal como está escrito e nunca é traduzido, pelo que tem de ser um esquema: um escalar de bloco que seja analisado como YAML, ou um mapeamento aninhado. Um conteúdo que não seja nenhum dos dois é recusado aqui em vez de ser passado adiante para servir de base a uma validação, onde a falha seria reportada contra o consumidor do esquema e não contra o esquema.
Quatro estruturas são reportadas sob esta condição, e a frase indica qual deles se verifica. O corpo de escape não é analisado como YAML. O valor do escape não é nem um escalar de bloco nem um mapeamento. Uma chave properties: contém algo que não é um mapeamento de nomes para esquemas. E, no nível mais externo, o documento entregue ao compilador está vazio ou contém um nó para o qual o leitor não tem regra.
As próprias frases do compilador da forma compacta:
compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): escape content does not parse as YAML: <what the parse reported> (compactform: o conteúdo do escape não é analisado como YAML) compactform at <path-inside-the-schema>:<line> (keyword "$jsonschema"): expected block-scalar string or nested mapping (compactform: esperava-se uma cadeia escalar de bloco ou um mapeamento aninhado) compactform at <path-inside-the-schema>:<line> (keyword "properties"): expected a mapping of property names to schemas (compactform: esperava-se um mapeamento de nomes de propriedades para esquemas) compactform: unsupported YAML node kind (compactform: tipo de nó YAML não suportado)
A condição sob a qual é registada é compactform: $jsonschema content invalid, que é aquilo para que o seu código curto é resolvido.
Como corrigir: escreva o corpo de escape como escalar de bloco em $jsonschema: — caso contrário, um corpo cuja primeira linha se lê como uma chave YAML é absorvido pelo mapeamento circundante, que é a causa comum — e verifique se o que contém é JSON Schema válido por si só. Onde o fragmento era suficientemente pequeno para ser expresso na forma compacta, remover o escape é a resposta mais simples.
A compact-form constraint does not apply to the type it was written on (Uma restrição em forma compacta não se aplica ao tipo em que foi escrita)
As restrições em forma compacta são distribuídas pelo tipo declarado do campo: min: e max: tornam-se um limite numérico num número, um limite de comprimento numa cadeia e um limite de contagem num array. Assim, uma restrição tem de estar num campo cujo tipo a aceite, e o tipo tem de ser um único valor para que a distribuição tenha sequer uma resposta.
Quatro estruturas são reportadas sob esta condição. Uma restrição escrita onde type: está ausente ou nomeia uma união, pelo que nada decide qual o limite pretendido. Uma restrição escrita num tipo que não aceita limites desse género — um objeto, ou um booleano. Um type: cujo valor não é nem um nome escalar nem uma sequência de nomes. E um valuesType: a que é dado algo diferente de um nome escalar.
As próprias frases do compilador da 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: a restrição aplica-se a um único tipo declarado (integer/number/string/array); o tipo não está resolvido (união ou ausente) — restrinja o tipo a um único valor ou remova esta restrição) compactform at <path-inside-the-schema>:<line> (keyword "<constraint>"): constraint applies to integer/number/string/array; declared type is <the type as written> (compactform: a restrição aplica-se a integer/number/string/array; o tipo declarado é o 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: esperava-se um nome de tipo escalar ou uma sequência de nomes de tipo (array de tipos do JSON Schema 2020-12); obteve-se um tipo de nó não suportado) compactform at <path-inside-the-schema>:<line> (keyword "valuesType"): expected a scalar type name (compactform: esperava-se um nome de tipo escalar)
A condição sob a qual é registada é compactform: constraint not valid for declared type, que é aquilo para que o seu código curto é resolvido.
Como corrigir: a frase nomeia as duas metades — a restrição e o tipo que encontrou. Restrinja type: a um único nome onde contém uma união, adicione-o onde estiver em falta, ou remova a restrição onde o campo aceita realmente qualquer um de vários tipos. Um limite que tem de variar com o tipo exprime-se como um conjunto de alternativas em $jsonschema:, em que cada ramo tem o seu próprio tipo e o seu próprio limite.
A $ref: is not written in a form the compiler can resolve (Uma referência não está escrita numa forma que o compilador consiga resolver)
Um esquema referencia outra estrutura com $ref:, seja dentro do mesmo documento, seja entre documentos para uma entrada de uma SchemaLibrary. Duas condições cobrem as duas formas como uma referência falha, e a frase indica qual é o caso: a referência não está escrita numa forma que o compilador lê, ou está bem formada e nomeia um destino que não existe.
A referência não é legível. O valor está vazio, ou a sua forma entre documentos não é <Library>#/schemas/<Entry>, ou separa a versão com @ — o que é reportado com a grafia corrigida em vez de uma queixa genérica, porque é o erro que esta forma mais atrai:
compactform at <path-inside-the-schema>:<line> (keyword "$ref"): expected a non-empty reference URL (compactform: era esperado um URL de referência não vazio) compactform at <consumer-document> (keyword "$ref"): cross-document $ref shape must be <LibraryName>#/schemas/<EntryName>: <the value as written> (compactform: um $ref entre documentos tem de ter a forma indicada) compactform at <consumer-document> (keyword "$ref"): cross-document $ref version separator is ’:’, not ’@’ — use <the corrected value>: <the value as written> (compactform: o separador de versão de um $ref entre documentos é ’:’, não ’@’ — utilize o valor corrigido)
A condição sob a qual são registados é compactform: $ref unresolvable.
O destino não existe. A referência lê-se corretamente e a biblioteca, ou a entrada dentro dela, está ausente — ou não foi fornecido nenhum catálogo de bibliotecas para a resolver:
compactform at <consumer-document> (keyword "$ref"): SchemaLibrary <library> not found in catalog (referenced from <consumer-document>): <the value as written> (compactform: SchemaLibrary não encontrada no catálogo) compactform at <consumer-document> (keyword "$ref"): entry <entry> not found in SchemaLibrary <library>: <the value as written> (compactform: entrada não encontrada na 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, mas nenhum catálogo de SchemaLibrary fornecido)
A condição sob a qual são registados é compactform: cross-document $ref target not found.
Manter os dois separados é o que torna o relatório acionável: o primeiro é um valor a reescrever no documento que se está a ver, e o segundo é uma questão sobre o que a compilação consegue ver. Uma referência que se expande em si mesma é ainda uma terceira coisa, e é reportada como «A library reference expands into itself (Uma referência de biblioteca expande-se em si mesma)» acima.
Como corrigir: para uma referência ilegível, reescreva o valor — <Library>#/schemas/<Entry> para uma referência entre documentos, #/$defs/<name> para uma dentro do mesmo documento — e utilize : antes de uma versão mínima em vez de @. Para um destino ausente, confirme o nome da entrada junto da biblioteca que a publica, e confirme que a biblioteca é alcançável a partir do fecho de dependências da Release: uma biblioteca da qual nada declara depender não é carregada, pelo que uma referência correta para ela continua a não se resolver em nada.
Quando a biblioteca está apenas na cache de artefactos. A cache contém o que uma obtenção lá colocou, e uma biblioteca em cache conta como conteúdo de catálogo apenas onde uma entrada no ficheiro de bloqueio da Release garante o seu digest. Quando a cache contém uma SchemaLibrary que nenhuma entrada do ficheiro de bloqueio fixa e que nenhum diretório de catálogo fornece, o relatório é seguido de uma linha remediation: que nomeia cada uma dessas bibliotecas e a ação que funciona para o comando que a reportou:
aggrega build e aggrega validate --release leem o ficheiro de bloqueio da Release, pelo que a sua linha nomeia aggrega pull --release <release>, que resolve a biblioteca e regista a sua entrada, ou a escrita da biblioteca num diretório de catálogo.
aggrega validate sem argumentos, e aggrega validate com o caminho de uma entidade, com ou sem --release, leem bibliotecas apenas de diretórios de catálogo e não leem nenhum ficheiro de bloqueio, pelo que uma entrada registada não mudaria o seu veredicto. A sua linha di-lo, e aponta para a escrita da biblioteca num diretório de catálogo, ou para aggrega pull --release <release> seguido de aggrega validate --release <release>, que verifica a Release face às bibliotecas que o seu ficheiro de bloqueio fixa.
A $ref: addresses a library by registry location (Uma referência endereça uma biblioteca pela sua localização no registo)
Um $ref: entre documentos nomeia a sua biblioteca pela identidade — o nome simples da biblioteca, depois # e o caminho da entrada — e nunca pelo registo em que por acaso está publicada. O registo através do qual um nome se resolve é configuração do espaço de trabalho, e a versão usada é a resposta do ficheiro de bloqueio, pelo que uma referência que contenha um host fixaria no esquema duas coisas que cabe à compilação decidir, e moveria o esquema entre espaços de trabalho como uma referência partida.
Onde o valor que contém o host ainda se decompõe numa biblioteca e numa entrada, a frase traz a grafia em forma de identidade a usar em alternativa:
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: o $ref entre documentos contém um host de registo; referencie a biblioteca pela identidade)
e onde não se decompõe, a frase termina após o valor:
compactform at <consumer-document> (keyword "$ref"): cross-document $ref carries a registry host; reference the library by identity: <the value as written> (compactform: o $ref entre documentos contém um host de registo; referencie a biblioteca pela identidade)
A condição sob a qual é registado é compactform: cross-document $ref carries a registry host; reference the library by identity, que é aquilo em que o seu código curto se resolve.
Como corrigir: remova o host e tudo o que antecede o nome da biblioteca, deixando <Library>#/schemas/<Entry>. Onde se pretende uma versão mínima, escreva-a após o nome da biblioteca como :<version>. A mesma regra rege os campos $import: numa Recipe e numa FeatureRecipe, que são reportados separadamente em «A library $import: addresses its library by registry location (Uma importação de biblioteca endereça a sua biblioteca pela localização no registo)» abaixo.
A schema $import: cannot be applied (Uma importação de esquema não pode ser aplicada)
O spec.schema de um Component ou de uma Feature — o bloco inteiro ou um dos seus pilares — e o valueSchema: ou o infraSchema: de um socket usesSchema podem cada um ser escritos como $import: a nomear um ficheiro ao lado da entidade. A importação é aplicada quando a entidade é carregada, pelo que cada leitor posterior vê o contrato importado em vez do ponteiro. Esta condição é o que acontece quando a culpa é de algo que se escreveu: a própria diretiva, ou a estrutura do que o ficheiro que ela nomeia acabou por conter.
Esses defeitos são uma única condição porque cada um deixa a mesma superfície inutilizável e dá a mesma coisa a fazer — corrigir a diretiva, ou o ficheiro que ela nomeia. O diagnóstico começa com a frase fixa e depois indica qual o defeito, pelo que a frase é a parte com que fazer a correspondência e a oração seguinte é aquilo sobre o qual agir:
a schema $import: could not be applied. <surface>: <the clause for this occurrence> (não foi possível aplicar uma importação de esquema)
A oração nomeia a superfície que leu — spec.schema, um dos seus pilares como spec.schema.values, ou o valueSchema de um socket — seguida do defeito específico. Os defeitos, e o que cada um significa:
$import: must be the only key when a schema is imported from a file. (A importação tem de ser a única chave quando um esquema é importado de um ficheiro.) A diretiva partilha o seu mapeamento com conteúdo de esquema escrito pelo autor. $import: substitui um valor inteiro, pelo que uma chave irmã não tem com que se combinar.
$import: value must be a path to a file. (O valor da importação tem de ser o caminho de um ficheiro.) O valor está vazio, ou não é uma única cadeia de caracteres.
$import: takes a file path beside this entity, not a registry location <value>. (A importação recebe o caminho de um ficheiro ao lado desta entidade, não uma localização de registo.) O valor endereça um registo. O registo através do qual um nome se resolve é configuração do espaço de trabalho, pelo que uma superfície de esquema nunca contém um; a mensagem nomeia, em alternativa, a forma de referência a usar.
$import: takes a file path beside this entity; reference the SchemaLibrary entry <value> with $ref: instead. (A importação recebe o caminho de um ficheiro ao lado desta entidade; em alternativa, referencie a entrada da SchemaLibrary.) O valor endereça uma entrada de biblioteca. Uma entrada de biblioteca é referenciada, não importada — $ref: é a palavra-chave que resolve uma.
imported schema <value> must be a YAML map of schema content; it is not. (o esquema importado tem de ser um mapa YAML de conteúdo de esquema; não é.) O ficheiro foi encontrado, lido e analisado, e o resultado é um escalar ou uma sequência, pelo que não há conteúdo de esquema a substituir.
O cabeçalho contém a categoria e o código curto desta condição, E0266, que é o identificador a registar quando for preciso nomear esta interrupção de forma duradoura — numa verificação de integração contínua, numa issue ou num runbook. Um número é atribuído uma vez e depois fica fixo, pelo que se mantém o mesmo por mais que a redação à sua volta melhore; a tabela de todas as condições resolve-o.
Uma diretiva bem formada que nomeia um ficheiro que a compilação não consegue obter é reportada noutro local, sob um código diferente. Um caminho que não se resolve, um ficheiro que não existe ou não pode ser lido, e bytes que não são analisados como YAML não são defeitos no que se escreveu — não há documento importado a avaliar — pelo que são reportados como o carregamento que são, em «A file cannot be read, or its bytes do not parse (Um ficheiro não pode ser lido, ou os seus bytes não são analisáveis)» acima, que documenta a oração que cada um deles contém. Faça a correspondência com essa condição, e registe o seu código, quando o que se pretende capturar é um ficheiro de importação em falta ou ilegível.
Um caminho é resolvido em relação ao diretório que contém o ficheiro da entidade, a mesma base que qualquer outro campo portador de importação usa. Uma importação cujo conteúdo declara, por sua vez, um $import: é seguida, e uma cadeia que regressa a um ficheiro já em processamento é reportada como «A library reference expands into itself (Uma referência de biblioteca expande-se em si mesma)» acima, e não aqui. Uma diretiva escrita dentro de um ficheiro trazido por uma importação é reportada nesse ficheiro e na linha correspondente, porque é aí que vai a correção; uma diretiva escrita na entidade é reportada na entidade.
Como corrigir: faça de $import: a única chave do seu mapeamento, e dê-lhe um caminho relativo para um ficheiro YAML ao lado da entidade cujo nível superior seja um mapa de conteúdo de esquema. Para consumir uma estrutura que uma SchemaLibrary publica, utilize em alternativa $ref: <Library>#/schemas/<Entry> — uma entrada de biblioteca é referenciada em vez de importada.
A schema block names a key that is not a data pillar (Um bloco de esquema nomeia uma chave que não é um pilar de dados)
O bloco spec.schema de um Component ou de uma Feature contém os pilares de dados da entidade, e três chaves são tudo o que admite: values, a estrutura que o programador preenche por instância; infra, o dimensionamento físico que o operador fornece; e provides, as chaves que a entidade expõe a quem a consome. Esta condição é o que acontece quando o bloco contém outra chave no seu nível superior.
O conjunto é fechado em vez de aberto, pela mesma razão pela qual o conteúdo de cada pilar é validado de forma fechada: um bloco que enumera uma superfície válida torna erro tudo o que fica fora dessa superfície. Uma chave que nada reconhece conteria um contrato que nada alguma vez compila, contra o qual nada valida e que nada entrega a um consumidor — pelo que o que se escreveu por baixo dela pareceria declarado e seria inerte. Isso é mais difícil de notar do que um contrato que nunca se escreveu, e é por isso que o bloco é recusado em vez de a chave avulsa ser ignorada.
O diagnóstico começa com a frase fixa e depois nomeia a entidade, a regra, o local onde a chave foi escrita e o que escrever em alternativa:
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. (um bloco de esquema declara uma chave que não nomeia nenhum pilar de dados, regra schema-pillars; mude o nome da chave para uma das chaves de pilar, ou remova-a juntamente com o contrato por baixo dela; permitidas: values, infra, provides. Consulte vocabulary/data-pillars.md para o conjunto canónico de pilares.)
O cabeçalho contém a categoria e o código curto desta condição, E0267, que é o identificador a registar quando for preciso nomear esta interrupção de forma duradoura — numa verificação de integração contínua, numa issue ou num runbook. Um número é atribuído uma vez e depois fica fixo, pelo que se mantém o mesmo por mais que a redação à sua volta melhore; a tabela de todas as condições resolve-o.
Duas coisas escritas nessa posição não são chaves deste conjunto, e nenhuma delas é reportada aqui. Um $import: que nomeia um ficheiro ao lado da entidade é substituído pelo conteúdo desse ficheiro antes de o bloco ser lido, pelo que o que esta condição inspeciona é o nível superior do próprio documento importado — uma chave avulsa dentro do ficheiro importado é reportada aqui, e a própria diretiva nunca. E um Component que declara extends escreve a cadeia simples inherited no lugar do bloco, que é um escalar sem qualquer chave.
Como corrigir: a frase nomeia a chave que encontrou e as três que admite, pelo que a causa mais comum — um erro de escrita, ou um singular onde o nome do pilar é plural — é visível apenas a partir do diagnóstico. Onde o conteúdo sob a chave avulsa pertence a um pilar, mova-o para values:, infra: ou provides: conforme a sua pertença determinar; data-pillars.md indica que pilar detém o quê. Onde foi pensado como conteúdo de esquema por direito próprio, pertence a um nível mais abaixo, dentro de um pilar, e não ao lado dos pilares. Uma estrutura publicada por uma SchemaLibrary é alcançada com $ref: <Library>#/schemas/<Entry> escrito dentro de um pilar, não ao nível do bloco.
A plugin asks the host to parse a source while a parse is already running for it (Um plugin pede ao host que analise uma origem enquanto já está em curso uma análise para ele)
Um plugin pode pedir ao host que analise uma origem e devolva o resultado, para que um plugin que precise de um documento num determinado formato não tenha de incluir um leitor para ele. O host executa o plugin que produz a análise e devolve o que este produziu. Esta condição é o que acontece quando o plugin alcançado dessa forma pede, por sua vez, uma análise: o pedido voltaria a entrar no mesmo mecanismo dentro do qual já está a ser executado, e o host recusa em vez de descer mais um nível. Um nível disto é o que o mecanismo oferece, e a recusa é o que o mantém em um.
A recusa chega ao plugin, não à compilação. O host não para aí nem desfaz a pilha; responde à chamada com um envelope de falha que contém a frase abaixo e um código que identifica a recusa, e o plugin que fez o pedido recebe-o como resposta ao seu pedido. O que a compilação faz depois depende do que esse plugin faz com a resposta — um plugin que a trata como fatal termina a compilação, um que a reporta e continua, não. A recusa em si é a mesma em ambos os casos.
Não é culpa de nenhum dos dois plugins em particular: a proteção abrange qualquer par de plugins pelo qual o pedido tenha passado, em vez de um emparelhamento específico, pelo que a mesma recusa surge onde quer que se volte a entrar no mecanismo.
Mensagem emitida, tal como o plugin a recebe:
aggrega_parse_source: producer-consumption re-entry denied: a producer reached through the host may not issue a further producer-consumption call (reentrada no consumo de produtor negada: um produtor alcançado através do host não pode emitir mais nenhuma chamada de consumo de produtor)
Como corrigir: nada nos seus próprios ficheiros causa isto e nenhuma alteração ao que escreveu o resolve — é uma propriedade dos plugins com que a compilação está configurada. O plugin a corrigir é o que pede uma análise de dentro de uma análise, pelo que a condição deve ser reportada a quem o publica, citando a mensagem. Se esse plugin for seu, deve fazê-lo ler diretamente a origem que lhe foi entregue, em vez de pedir ao host que analise outra enquanto ele próprio está a servir uma análise.
The workspace configuration is invalid (A configuração do espaço de trabalho é inválida)
Um espaço de trabalho é descrito por um .aggrega-config.yaml na sua raiz: em que registo publica e de que registo obtém, onde fica a cache de artefactos, que plugins estão anexados a que sockets e qual é a posição de cada registo quanto à assinatura. Esse ficheiro é lido e verificado face ao seu esquema antes de ser aberto qualquer ficheiro de entidade, porque tudo o que se segue é lido a partir dele.
Um ficheiro em falta não é uma falha. Um espaço de trabalho sem ficheiro de configuração recebe os valores predefinidos documentados, pelo que esta interrupção nunca nomeia um ficheiro ausente. Nomeia o ficheiro que continha o valor — ou, para uma definição que uma variável de ambiente substitui e que o esquema nunca vê, a variável.
A verificação é executada antes de o documento ser transformado em definições tipadas. É essa ordem que permite à mensagem nomear o caminho do campo a que o esquema objetou, em vez de reportar uma incompatibilidade de tipo a partir de um ponto mais adiante, sem nenhum campo para indicar.
Estas estruturas são reportadas aqui para além de uma simples objeção do esquema, cada uma porque o esquema, por si só, apenas consegue dizer algo demasiado genérico para se poder agir: uma chave workspace: escrita sem nada por baixo, uma chave cujo lugar é o nível superior escrita em vez disso por baixo de workspace:, um bloco cache: escrito com um nome que o ficheiro não usa, um host de registo não escrito da forma como se escreve um host de registo, e três definições cujos valores o esquema admite mas que o espaço de trabalho não pode usar — um artifact_cache_dir que é absoluto ou que nomeia a própria raiz do espaço de trabalho, uma entrada de signing.kinds que nomeia algo que não é um tipo de artefacto publicável, e uma entrada de plugins.providers ou providers_append cujo uri é uma localização de registo escrita com oci://. Uma associação de fornecedor nomeia o seu plugin pela sua identidade, provider/<name> com um :<version> opcional, porque é com essa identidade que a associação é comparada quando uma capacidade é resolvida; uma localização de registo diz onde um plugin está publicado, não qual plugin é, pelo que uma entrada escrita assim nunca poderia selecionar nada. Uma entrada que nomeia uma função de entrada com function: e nenhum uri: também é reportada aqui, quando é uma entrada de plugins.linter ou linter_append ou uma entrada de plugins.governance ou governance_append num papel de veredicto, ir-verdict ou render-verdict: esses anexos selecionam o seu plugin por uri, pelo que uma entrada destas não anexa nenhum plugin e a função que nomeia nunca seria chamada — um lint continuaria como se a entrada não existisse, e uma compilação só pararia mais tarde, ao ter de resolver um plugin que a entrada nunca nomeou.
Um diretório de catálogo que a configuração lista — em workspace.catalog_dirs ou catalog_dirs_append, ou na própria entrada de uma Release em workspace.releases, em qualquer ficheiro a partir do qual a configuração é lida — também é reportado aqui quando não é um diretório: nada existe no caminho, ou está lá um ficheiro ou uma ligação que não leva a lado nenhum. É avaliado quando um catálogo está prestes a ser lido através dele, pelo que todo o comando que lê o catálogo o recusa antes de ler ou escrever o que quer que seja, enquanto um comando que não lê nenhum catálogo continua a ser executado. Prosseguir a leitura sem ele compilaria com menos catálogos do que os que foram listados, sem nada que indicasse quais. Um diretório que AGGREGA_CATALOG_DIRS lista está sujeito à mesma regra, e a recusa nomeia a variável em vez de um ficheiro.
Um host de registo — o host de uma entrada de registries, ou o host com que default_registry começa quando não nomeia uma dessas entradas pelo seu name:, caso em que representa o host dessa entrada — escreve-se como o próprio host: em minúsculas, contendo um ponto, ou localhost, ou um único nome seguido de uma porta, ou um endereço IP (um IPv6 entre parênteses retos), cada um com um :port opcional, e sem esquema nem credenciais. O host de uma entrada de registries não tem caminho; default_registry pode fazer seguir o seu host de / e de um caminho de repositório — segmentos em minúsculas unidos por /, sem tag, digest nem / final. Um valor que nomeia um host com outra grafia é recusado indicando a grafia a escrever — para default_registry, a localização completa, caminho incluído — para que a política de confiança mantida sob esse host se lhe aplique; isso inclui a porta 443 num host acedido por HTTPS, já que é a porta predefinida desse host. Um caminho que não é um caminho de repositório é recusado nomeando o host a que se segue, e o name: de uma entrada seguido de um caminho é recusado nomeando as duas grafias a escrever em vez disso, o nome sozinho ou o host da entrada seguido do caminho, já que um nome representa o host da sua entrada e não uma localização abaixo dele. Um valor que não nomeia host algum — um único nome sem porta que nenhuma entrada tem, um texto com espaços ou chavetas — é recusado como não sendo um host, e para default_registry a recusa diz que o nome de uma entrada também serviria. AGGREGA_DEFAULT_REGISTRY está sujeito à mesma leitura e é recusado da mesma forma, nomeando a variável.
Mensagens emitidas. Uma objeção do esquema nomeia o ficheiro, o caminho do campo e o que o esquema disse:
workspaceconfig: <path>: <field-path>: <the schema's own objection>: workspace configuration is invalid (a configuração do espaço de trabalho é inválida)
As formas com correção começam pelo ficheiro e dizem uma frase sobre a estrutura específica em vez do caminho do campo e da objeção do esquema. Um artifact_cache_dir que nomeia a raiz do espaço de trabalho:
<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 nomeia a própria raiz do espaço de trabalho; um diretório de catálogo na raiz do espaço de trabalho seria então ignorado como cache, não deixando nada para carregar — atribua à cache um subdiretório próprio: a configuração do espaço de trabalho é inválida)
uma entrada de signing.kinds inutilizável, que também nomeia o caráter universal que abrange todos os 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 (a entrada de signing.kinds não é um tipo de artefacto assinável; use um tipo de entidade de catálogo ou de plugin, ou o caráter universal para todos os tipos: a configuração do espaço de trabalho é inválida)
uma associação de fornecedor escrita como uma localização de registo, que nomeia a entrada, a capacidade e a forma a escrever:
<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 associa a capacidade a uma localização, que indica onde um plugin está publicado e não qual plugin é; uma associação de fornecedor nomeia o seu plugin pela sua identidade — escreva uri com a identidade do fornecedor, com uma versão opcional: a configuração do espaço de trabalho é inválida)
um anexo de linter ou de governação em papel de veredicto que nomeia uma função de entrada e nenhum plugin, cuja mensagem nomeia a lista, a entrada e a função, aqui em 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 nomeia a função de entrada, mas nenhum uri de plugin; um anexo nesta lista seleciona o seu plugin por uri, pelo que este não anexa nenhum plugin e a função nunca é chamada — adicione o uri do plugin que a exporta: a configuração do espaço de trabalho é inválida)
um host de registo escrito com outra grafia, aqui HUB.AGGREGA.AI:
<path>: default_registry "HUB.AGGREGA.AI" is not written as the registry host it names; write "hub.aggrega.ai" — lowercase, with no scheme, path, credentials or default port — which is the spelling that host’s trust policy is kept under: workspace configuration is invalid (default_registry não está escrito como o host de registo que nomeia; escreva-o — em minúsculas, sem esquema, caminho, credenciais nem porta predefinida — que é a grafia sob a qual a política de confiança desse host é mantida: a configuração do espaço de trabalho é inválida)
um registo predefinido cujo host está escrito com outra grafia antes do seu caminho de repositório, aqui GHCR.io/acme, cuja mensagem nomeia a localização completa a escrever:
<path>: default_registry "GHCR.io/acme" is not written as the registry location it names; write "ghcr.io/acme" — the registry host lowercase, with no scheme, credentials or default port, followed by the repository path — which keeps that host’s trust policy applying to it: workspace configuration is invalid (default_registry não está escrito como a localização de registo que nomeia; escreva-a — o host do registo em minúsculas, sem esquema, credenciais nem porta predefinida, seguido do caminho de repositório — o que mantém a política de confiança desse host aplicada a ela: a configuração do espaço de trabalho é inválida)
o nome de uma entrada seguido de um caminho, aqui local/acme onde a entrada chamada local é para 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 é o nome da entrada de registries seguido de um caminho, e o nome de uma entrada representa apenas o host dessa entrada; escreva só o nome para usar a entrada, ou o host dela seguido do caminho: a configuração do espaço de trabalho é inválida)
um valor que não nomeia nenhum host, cuja frase lista as formas que um host assume:
<path>: registries[<n>].host "<value>" is not a registry host; write a lowercase host name containing a dot (registry.example.com), localhost, a single name followed by a port (registry:5000), or an IP address, an IPv6 one in brackets — each with an optional :port and nothing else: workspace configuration is invalid (o host da entrada de registries não é um host de registo; escreva um nome de host em minúsculas que contenha um ponto (registry.example.com), localhost, um único nome seguido de uma porta (registry:5000) ou um endereço IP, um IPv6 entre parênteses retos — cada um com um :port opcional e nada mais: a configuração do espaço de trabalho é inválida)
um diretório de catálogo listado onde nada existe, cuja mensagem nomeia o ficheiro e a linha, a lista, a entrada tal como foi escrita e o caminho para o qual foi resolvida — a lista é workspace.catalog_dirs, workspace.catalog_dirs_append ou a lista de uma 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 (a entrada de workspace.catalog_dirs nomeia um diretório que não existe; crie esse diretório ou remova a entrada: a configuração do espaço de trabalho é inválida)
e um marcador workspace: vazio:
workspaceconfig: <path>: workspace must be a mapping; write workspace: {} to mark a workspace root with no catalog directories: workspace configuration is invalid (workspace tem de ser um mapeamento; escreva um mapeamento vazio para marcar uma raiz de espaço de trabalho sem diretórios de catálogo: a configuração do espaço de trabalho é inválida)
Outras duas nomeiam uma chave escrita no sítio errado — default_registry, offline, auto_pull e artifact_cache_dir ficam todas no nível superior e não por baixo de workspace:, e o bloco da cache de análise é parse_cache:. Cada uma diz a que chave se refere e onde essa chave deve ficar.
Como corrigir: abra o ficheiro que a mensagem nomeia e vá ao caminho do campo que ela cita. Quando a mensagem contém uma frase de correção, nomeia diretamente a grafia ou a posição correta e não é preciso ler mais nada. Quando contém, em vez disso, uma objeção do esquema, o caminho do campo é a chave com erro e a objeção diz o que o esquema esperava ali — as páginas de entidades não regem este ficheiro, pelo que se deve ler a objeção em vez de procurar um contrato de entidade. Um artifact_cache_dir escreve-se em relação à raiz do espaço de trabalho e precisa de um subdiretório próprio, para que um diretório de catálogo na raiz do espaço de trabalho não seja confundido com cache e ignorado. Uma associação de fornecedor escrita como localização de registo é reescrita à mão com a identidade do plugin — oci://hub.aggrega.ai/plugin/provider/compose passa a provider/compose — porque todo o comando que lê o ficheiro o recusa até que isso seja feito, aggrega plugin remove incluído; aggrega plugin add provider escreve por si próprio a forma com a identidade. Uma entrada de linter ou de governação em papel de veredicto que nomeia uma função e nenhum plugin recebe o uri do plugin que exporta essa função; se nenhum a exportar, remova a entrada — na lista de linters, o linter predefinido é então executado como quando nenhum linter está configurado. Um diretório de catálogo listado que não é um diretório é criado no caminho que a recusa nomeia, ou a sua entrada é removida da linha que a recusa nomeia; uma cópia de um projeto feita sem um checkout irmão que ele lista remove essa entrada.
A plugin binding sets a key the socket it attaches to does not read (Uma associação de plugin define uma chave que o socket ao qual se anexa não lê)
Os sockets da configuração do espaço de trabalho anexam plugins de duas formas diferentes, e uma chave que pertence a uma delas não significa nada na outra. Em vez de aceitar a chave e ignorá-la em silêncio, a configuração é recusada, para que um operador saiba que a definição é inerte, em vez de se perguntar mais tarde por que razão não teve efeito.
As duas incompatibilidades são imagens espelhadas uma da outra.
Um socket transversal associado por capacidade. Os sockets de governação, de linter e de importador anexam um plugin diretamente através de uri:. Um plugin de governação ou de linter não serve nenhuma capacidade, pelo que uma associação capability: aí seria procurada contra nada e não corresponderia a nada — um anexo que nunca se pode resolver. Um importador anuncia de facto os formatos que trata, mas qual o formato pretendido cabe à importação dizer, e não ao anexo: um anexo de importador nomeia o seu importador através de uri:, e é isso que o escolhe entre os importadores que anunciam o formato pedido por uma importação.
Um socket de fornecedor a definir uma chave sem referente. Uma associação de fornecedor nomeia uma capacidade e o plugin que a serve, e o plugin aciona um conjunto fixo de exportações em vez de uma única entrada selecionável, pelo que function: não nomeia nada nela. with: é recusado por outro motivo: a configuração de renderização de um fornecedor é escrita na Recipe, pelo que colocá-la na associação do espaço de trabalho a põe do lado errado da separação entre programador e operador.
Mensagens emitidas. Uma capacidade num 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 (o socket está associado por capacidade, mas os sockets transversais anexam-se por uri: o seu plugin não serve nenhuma capacidade, pelo que uma procura por capacidade não corresponde a nada; anexe-o antes por uri: um socket transversal está associado por capacidade, mas anexa-se por uri)
um function: inerte numa associação de fornecedor:
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 (a associação do socket de fornecedor para a capacidade define este campo, mas um fornecedor aciona um conjunto fixo de exportações associadas a fases em vez de uma única entrada selecionável, pelo que o campo não nomeia nada aí; remova-o: uma associação de socket de fornecedor define um campo sem referente nesse socket)
e um with: inerte, que é comunicado com a mesma estrutura e indica antes onde a configuração deve ficar:
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 (a associação do socket de fornecedor para a capacidade define este campo, mas a configuração de renderização do fornecedor pertence à Recipe, não à associação de fornecedor do espaço de trabalho; remova-o: uma associação de socket de fornecedor define um campo sem referente nesse socket)
Um function: escrito em .aggrega-config.yaml não chega à frase acima: o esquema da configuração do espaço de trabalho não declara essa chave numa associação de fornecedor, pelo que o ficheiro é recusado primeiro, sob E0224, e a solução é a mesma — remover a chave:
workspaceconfig: <file>: plugins.providers[<index>].function: against /$defs/FixedEntryPluginRef: unexpected property: “function”: workspace configuration is invalid (plugins.providers[].function: em relação a /$defs/FixedEntryPluginRef: propriedade inesperada: “function”: a configuração do espaço de trabalho é inválida)
Como corrigir: a correção faz-se em .aggrega-config.yaml e cada mensagem nomeia a edição exata. Num anexo de governação, de linter ou de importador, substitua o capability: pelo uri: do plugin que pretendia anexar. Numa associação de fornecedor, remova a chave nomeada — e, se era with:, mova essa configuração para a Recipe que renderiza através do fornecedor, que é a superfície que a lê.
A capability is bound to more than one provider plugin (Uma capacidade está associada a mais de um plugin fornecedor)
Uma capacidade nomeia uma forma de transformar um workload em artefactos, e exatamente um plugin a serve num espaço de trabalho resolvido. Duas associações para uma capacidade não deixam resposta sobre qual delas renderiza, e uma configuração do espaço de trabalho é montada a partir de várias camadas — um ficheiro partilhado, um ficheiro do espaço de trabalho e os ficheiros complementares de acréscimo com que cada um pode contribuir —, pelo que a segunda associação é muitas vezes contribuída por uma camada cujo autor não podia ver a primeira.
A recusa é o que torna isso visível. Deixar uma associação prevalecer em silêncio faria a saída renderizada depender da camada que, por acaso, foi lida em último lugar.
Mensagem emitida, que nomeia a capacidade e a regra:
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 (a capacidade está associada a mais de um plugin fornecedor; mantenha exatamente uma entrada plugins.providers por capacidade: a capacidade está associada a mais de um plugin fornecedor)
Como corrigir: mantenha uma única entrada plugins.providers para a capacidade que a mensagem nomeia e remova a outra. Quando as duas vêm de camadas de configuração diferentes, a camada a editar é aquela que controla — remover a própria entrada adota a que a camada partilhada contribui, e manter a sua significa que é a entrada da camada partilhada que tem de sair. Dois plugins que servem realmente ambos o espaço de trabalho servem duas capacidades diferentes, pelo que, se ambos forem pretendidos, atribua a cada um a sua própria capacidade em vez de associar uma duas vezes.
An importer is attached by more than one plugins.importer entry (Um importador está anexado por mais de uma entrada)
Uma entrada plugins.importer anexa o importador que o seu uri nomeia: quando esse importador anuncia o formato pedido por uma importação, a entrada decide qual a versão dele que é executada e entrega-lhe os with.sources e with.settings da entrada. Uma entrada faz isso para um importador, pelo que uma segunda entrada que nomeie o mesmo importador — a mesma identidade, na mesma versão ou noutra — não seria lida por nada, e o seu with não chegaria a nenhum importador sem que uma palavra fosse dita. Em vez disso, a configuração é recusada ao ser carregada, seja qual for o comando que a leia.
Uma configuração do espaço de trabalho é montada a partir de vários ficheiros — o ficheiro global, cada .aggrega-config.yaml desde a raiz do projeto até ao diretório em que um comando é executado, o ficheiro complementar importer_append que cada um pode ter e o .aggrega-config-append-ci.yaml de um pipeline —, pelo que a segunda entrada é muitas vezes escrita num ficheiro diferente do da primeira. A mensagem nomeia o importador e ambas as entradas, a anterior primeiro, cada uma pela chave e pela posição sob as quais está escrita, pelo ficheiro em que foi escrita e pelo seu uri tal como aí está escrito.
Apenas a lista de importadores é avaliada: as listas de governação e de linter aceitam um plugin anexado mais de uma vez, levando cada anexo o seu próprio with. Uma entrada cujo uri é um caminho do sistema de ficheiros não nomeia nenhum importador, pelo que não é comparada.
Mensagem emitida:
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 (o importador está anexado por uma entrada num ficheiro e novamente por uma entrada num ficheiro; mantenha exatamente uma entrada plugins.importer por importador, com o seu uri a nomear a versão pretendida: o importador está anexado por mais de uma entrada plugins.importer)
Como corrigir: mantenha uma única entrada para o importador que a mensagem nomeia — aquela cujo uri nomeia a versão pretendida, com o with que se pretende entregar a esse importador — e remova a outra. Quando as duas estão em ficheiros diferentes, o ficheiro a editar é aquele que controla: remover a sua entrada adota a do outro ficheiro, e manter a sua significa que é a entrada do outro ficheiro que tem de sair.
A provider binding names a capability containing a colon (Uma associação de fornecedor nomeia uma capacidade que contém dois pontos)
O capability: de uma Recipe é lido como o nome da capacidade até aos seus últimos dois pontos e uma fixação de versão a seguir — helm:1.0.0 pede a capacidade helm na versão 1.0.0. Uma entrada plugins.providers é procurada por esse nome, pelo que a capacidade que uma associação nomeia nunca contém dois pontos, e uma entrada cuja capacidade os contenha é uma entrada que nenhuma Recipe consegue alguma vez alcançar. Em vez de a deixar na configuração sem ser lida, a configuração é recusada ao ser carregada, seja qual for o comando que a leu.
Apenas a lista de fornecedores é avaliada. A lista de importadores partilha a estrutura das entradas, mas os seus plugins são anexados através de uri: e nomeiam os seus formatos import:<format>, em que os dois pontos fazem parte do nome. O uri: de uma associação pode ainda assim terminar em :<version>; essa não é a parte que esta regra lê.
Mensagem emitida, que nomeia a capacidade:
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 (a associação do socket de fornecedor para a capacidade: a referência de capacidade de uma Recipe é lida como a capacidade até aos seus últimos dois pontos e uma fixação de versão a seguir, pelo que a capacidade que uma associação nomeia não contém dois pontos; associe apenas o nome da capacidade e deixe cada Recipe fixar a versão de que precisa: uma associação de socket de fornecedor nomeia uma capacidade que contém dois pontos, que nenhuma Recipe consegue selecionar)
Como corrigir: escreva apenas o nome da capacidade na entrada — capability: helm — e fixe as versões onde elas pertencem: uma Recipe fixa a versão do fornecedor de que precisa no seu próprio capability:, e uma associação que deva selecionar uma versão específica do seu plugin escreve-a na identidade do plugin, uri: provider/helm:1.0.0.
A governance attachment declares no role, or one that is not a known role (Um anexo de governação não declara nenhum papel, ou declara um que não é um papel conhecido)
Um anexo de governação leva um papel, e é o papel — não o tipo declarado pelo próprio plugin — que determina onde o anexo é executado e o que pode fazer: se aceita ou rejeita uma compilação, e se lê o grafo ou os artefactos renderizados. Os anexos são despachados através da leitura desse papel, pelo que um anexo sem nenhum, ou com um que ninguém reconhece, não se anexaria a nada e seria ignorado em silêncio.
É esse silêncio que a recusa impede. Um plugin de governação que está configurado e nunca é consultado produz exatamente a saída de uma compilação que nunca foi sujeita a governação, e nada no resultado indica qual das duas se tem em mãos.
Mensagens emitidas, ambas a nomear o anexo e a listar os papéis que existem. Um papel em falta:
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 (o anexo de governação não declara nenhum papel; defina o papel como um dos papéis conhecidos: um anexo de governação não declara nenhum papel ou declara um papel desconhecido)
e um não reconhecido:
workspaceconfig: governance attachment "<uri>" declares unknown role "<role>"; use one of <the known roles>: a governance attachment declares no role or an unknown role (o anexo de governação declara um papel desconhecido; use um dos papéis conhecidos: um anexo de governação não declara nenhum papel ou declara um papel desconhecido)
Como corrigir: defina role: no anexo sob plugins.governance como um dos papéis que a mensagem lista. Qual escolher é uma decisão sobre o que se pretende que o plugin faça, e não sobre o plugin: um papel que aceita ou rejeita lê a compilação e devolve um veredicto, e um papel que transforma é uma instrução explícita para deixar o plugin alterar o que recebe. A mensagem lista o conjunto completo, pelo que a grafia a usar está na própria mensagem.
A registry alias matches more than one host (Um alias de registo corresponde a mais de um host)
Pode atribuir-se a um registo um alias curto na configuração do espaço de trabalho, para que os comandos e as referências o possam nomear sem escrever o host por extenso. Um alias seleciona exatamente um host. Esta condição é o que comunica um token que corresponde ao alias de duas entradas de registo: não há resposta sobre qual era o host pretendido, e escolher um enviaria em silêncio artefactos para um registo que o autor não nomeou, ou obtê-los-ia dele.
Mensagem emitida, que nomeia o alias, quantas entradas o reivindicaram e quais são os hosts:
registry alias "<alias>" matches <count> hosts (<hosts>); address the registry by host or remove the duplicate alias: registry alias matches more than one host (o alias de registo corresponde a vários hosts; designe o registo pelo host ou remova o alias duplicado: o alias de registo corresponde a mais de um host)
Como corrigir: abra .aggrega-config.yaml e atribua o alias a um dos hosts que a mensagem lista, ou designe o registo pelo seu host e retire o alias da referência. A mensagem nomeia cada host que detém o alias, pelo que as entradas a examinar estão na mensagem. Quando as entradas vêm de camadas de configuração diferentes, edite a camada que lhe pertence.
The lockfile does not satisfy its schema (O ficheiro de bloqueio não satisfaz o seu esquema)
O ficheiro de bloqueio de uma release regista aquilo para que a compilação foi resolvida: para cada entidade, biblioteca e plugin que alcança, a versão selecionada e o digest dos bytes nessa versão. É lido e verificado em relação ao seu esquema antes de ser convertido em fixações tipadas, de modo que um documento que não se ajusta é recusado com o caminho do campo em que falhou, em vez de produzir em silêncio fixações com lacunas.
O ficheiro de bloqueio é escrito por máquina. É produzido pelo pull que resolve uma release e é incluído num commit para que a mesma compilação seja resolvida da mesma forma mais tarde. Por isso, uma falha de esquema é quase sempre uma edição manual, um merge que deixou o documento resolvido a meio ou um ficheiro de bloqueio escrito para uma forma anterior do ficheiro — um cujas entities não têm kind, por exemplo —, e não algo escrito deliberadamente.
Um ficheiro de bloqueio em falta é uma condição diferente e é comunicado de outra forma — o ficheiro de bloqueio é obrigatório, pelo que a sua ausência é comunicada onde a compilação o procura, com a instrução de executar o pull que o cria.
Mensagem emitida, que nomeia o ficheiro, o caminho do campo e a objeção do próprio esquema:
lockfile: <path>: <field-path>: <the schema's own objection>: lockfile: file failed schema validation (lockfile: lockfile: o ficheiro falhou a validação do esquema)
Uma compilação, tal como aggrega pull --verify, acrescenta o comando que volta a escrever o ficheiro de bloqueio:
…: lockfile: file failed schema validation; run aggrega pull --release <release> to write it again from the Release (lockfile: o ficheiro falhou a validação de esquema; execute o comando para o voltar a escrever a partir da Release)
Um documento totalmente vazio é comunicado à parte, uma vez que não há nenhum campo a nomear:
lockfile: <path>: document is empty (lockfile: o documento está vazio)
Como corrigir: não repare o ficheiro de bloqueio à mão. Volte a executar o pull para a release, que reescreve o documento a partir da resolução que efetua, e inclua o resultado num commit — é a nova resolução que produz um documento cujas fixações concordam com o que a release realmente alcança. Quando a falha se seguiu a um merge, resolver o conflito voltando a executar o pull, em vez de editar, é o que evita um documento que é analisado corretamente mas fixa as versões erradas. Vale a pena ler primeiro o caminho do campo na mensagem: indica se o dano está numa entrada ou na estrutura geral do documento.
Ao resolver o catálogo
Após o carregamento, o compilador percorre os dois níveis do Manifest (mapeamento de tipos, depois mapeamento de nomes) para escolher a Recipe de cada Component, e percorre todas as cadeias extends em Manifests, Components ou Features. A própria cadeia extends de uma Release é seguida pelo mesmo percurso, um passo antes: é seguida enquanto a Release é resolvida, antes de se procurar o Manifest ou o Aggregate que ela nomeia, pelo que as condições abaixo são comunicadas relativamente à Release e não a um ponteiro irmão que a cadeia iria fornecer.
Cyclic extends chain (Cadeia extends cíclica)
Uma cadeia de ponteiros extends volta sobre si própria. Cada tipo que declara extends — Component, Feature, Manifest e Release — é percorrido por um único percurso de cadeia, pelo que um ciclo é comunicado com as mesmas palavras onde quer que seja encontrado.
Mensagem emitida. Abre com a frase que nomeia a condição, depois a entidade a partir da qual a resolução começou e a regra que a recusou, e depois a aresta que fecha o ciclo — a entidade que contém o extends: problemático e a referência 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 (cadeia extends cíclica (tipo e nome, regra extends). A entidade estende a referência, que já está na cadeia; remova o extends da entidade ou aponte-o para uma entidade fora da cadeia)
A entidade nomeada primeiro e a entidade nomeada na aresta são normalmente diferentes, e é precisamente essa a questão: um ciclo é comunicado relativamente a cada entidade que dele faz parte, enquanto a linha extends: a editar é a que a aresta nomeia. Deve seguir-se a aresta, não o cabeçalho.
Para um Manifest, <kind> é Manifest, cada entidade é nomeada pelo seu metadata.name, e <reference> é o valor de extends: exatamente como escrito — um caminho relativo como ./base.yaml, ou o metadata.name simples de um Manifest ao lado da Release. Qual das duas formas foi escrita não altera o que é comunicado: um elo de Manifest é o ficheiro para o qual se resolve, pelo que dois ficheiros de Manifest que por acaso declaram o mesmo metadata.name são dois elos e uma cadeia que passa por ambos não é um ciclo.
Uma Release lê-se da mesma forma, e a questão da identidade do ficheiro conta mais aí, porque a estrutura que protege é comum: <kind> é Release, <reference> é o caminho relativo que extends: nomeia, e um elo de Release é o ficheiro para o qual se resolve. Dois ficheiros de Release que nomeiam o sistema implementado em vez do ambiente — ambos metadata.name: shared-release, um a estender o outro — são dois elos, e uma cadeia que passa por ambos não é um ciclo.
Um ciclo é comunicado como ciclo, seja qual for o seu comprimento. O percurso de cadeia aplica o seu limite de profundidade apenas a uma cadeia que termina, pelo que um ciclo que abrange mais entidades do que o limite permite continua a ser comunicado aqui e não como uma cadeia demasiado profunda — o remédio para um ciclo nunca é encurtá-lo.
Como corrigir: abrir a entidade que a aresta nomeia e remover o seu extends: ou apontá-lo para uma entidade que ainda não esteja na cadeia. Onde vários níveis deviam partilhar conteúdo, reunir o conteúdo duplicado numa única entidade base remove ao mesmo tempo o ciclo e a duplicação.
Recipe implements does not match the mapped component type (A declaração de implementação da Recipe não corresponde ao tipo de componente mapeado)
A entrada de mapeamento do Manifest aponta para uma Recipe cuja declaração spec.implements: não corresponde à chave de tipo de componente dessa entrada de mapeamento. spec.implements é uma âncora de coerência e não um mecanismo de despacho: o valor do mapeamento nomeia diretamente a Recipe, e esta verificação confirma que a Recipe que o autor nomeou é uma que declara o tipo que mapeou.
A verificação lê o Manifest composto antes de qualquer Recipe ser resolvida, pelo que comunica a entrada de mapeamento que o autor escreveu e não um sintoma a jusante dela.
Mensagem emitida:
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) (a spec.implements da receita da entrada de mapeamento do manifesto não corresponde à chave de tipo de componente / tipo de funcionalidade mapeada (mapeamento do manifesto do tipo de componente para o URI da receita, a spec.implements da receita é o valor declarado, esperado o tipo de componente ou um tipo que ele estende))
Todos os comandos que leem as dependências de uma Release realizam esta verificação; o que difere é o que cada um faz com o resultado.aggrega build e aggrega pull interrompem-se, porque ambos produzem algo que se vai usar a seguir — artefactos renderizados e um ficheiro de bloqueio. aggrega validate e aggrega lint comunicam a constatação juntamente com todos os outros diagnósticos encontrados e depois terminam com um código diferente de zero: a sua função é indicar tudo o que está errado no espaço de trabalho, pelo que um único defeito não encurta o relatório. No editor, a constatação é publicada como um diagnóstico ao lado dos outros, e tudo o resto que esse documento tinha a comunicar não é afetado. Note-se onde aparece: o editor publica a constatação no Manifest em que o mapeamento está escrito, na chave da entrada de mapeamento que indica, e não no Aggregate — na primeira linha do Manifest quando o seu texto aberto não escreve essa entrada, como no caso de uma entrada que herda através de extends. As restantes constatações ao nível das dependências da Release, que não indicam nenhum documento do espaço de trabalho, permanecem no Aggregate. Executar aggrega validate comunica-a qualquer que seja o documento aberto.
Uma entrada de mapeamento que nomeia uma Recipe que o catálogo não contém não é esta condição: a verificação não tem nada com que comparar e ignora a entrada, e a Recipe que não é possível resolver é comunicada quando as receitas são resolvidas.
As entradas de FeatureRecipe seguem a mesma estrutura; a verificação do mapeamento features.type emite manifest feature mapping ... featurerecipe spec.implements is ... (expected ...), e o ramo das funcionalidades compara com a própria chave de mapeamento, pelo que não nomeia nenhuma alternativa extends.
Uma chave components.type é também avaliada por instância sempre que alcança uma instância de outra versão. Uma chave que não nomeia o tipo exato de uma instância alcança-a pela base do tipo, quando nenhuma chave nomeia esse tipo exato e nenhuma outra chave está escrita para a mesma base — pelo que uma chave escrita sem versão, ou uma que nomeia outra versão, pode alcançá-la. A entrada, por si só, não pode portanto dizer se a sua Recipe é adequada, pelo que a compilação volta a avaliar a Recipe para cada instância de componente que a chave alcança dessa forma, com o próprio tipo da instância, na versão com que a compilação a compila, no lugar da chave: a versão que a instância nomeia ou, para uma instância que não nomeia nenhuma, a versão mais alta desse Component que o catálogo contém. Uma instância cuja versão a spec.implements: da Recipe não satisfaz — exatamente, por intervalo caret, por não ter versão, ou através de uma base que o tipo da instância estende com extends — levanta esta condição, comunicada no caminho .spec.components.<instance> da instância e não no ficheiro do 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 (a spec.implements da receita da entrada de mapeamento do manifesto não corresponde à chave de tipo de componente / tipo de funcionalidade mapeada (Manifest, no caminho da instância, instância do tipo de componente, compilada como tipo e versão, alcançada pela chave de mapeamento do manifesto, mapeada para a receita, cuja spec.implements é o valor declarado). mapeie este tipo nesta versão para uma receita que o implemente, com uma chave de mapeamento que nomeie a versão)
O valor compiled as só aparece para uma instância cujo tipo não nomeia nenhuma versão; uma instância que nomeia uma mostra a sua versão em of type. Uma chave que nomeia a própria versão da instância não precisa de uma segunda avaliação, uma vez que a verificação sobre a entrada já fez essa pergunta, e uma entrada já recusada pela sua chave é comunicada uma vez, como acima, e não mais uma vez para cada instância. aggrega build e aggrega pull interrompem-se nela, e aggrega validate --release comunica-a e termina com um código diferente de zero. aggrega lint avalia as entradas de mapeamento de um Manifest e não as instâncias que estas alcançam, pelo que não a comunica.
Como corrigir: corrigir a declaração spec.implements: da Recipe para que corresponda à chave de tipo de componente do Manifest, ou alterar a entrada do Manifest para que aponte para uma Recipe cuja spec.implements: corresponda à chave de tipo de componente. Para uma instância que uma chave alcança noutra versão, adicionar uma chave de mapeamento que nomeie a versão da instância, mapeada para uma Recipe que a implemente, ou apontar a chave que a alcança para uma Recipe desse tipo.
Manifest mapping value is not a shape a recipe reference accepts (O valor de mapeamento do Manifest não tem uma estrutura que uma referência de receita aceite)
Um valor de mapeamento do Manifest nomeia uma Recipe ou FeatureRecipe numa estrutura que a gramática de referências não consegue exprimir. Uma referência de receita aceita um nome simples, um nome com versão, um nome qualificado pela capacidade ou um nome qualificado pela capacidade com versão — no máximo uma /. Um valor que contenha mais do que isso (um caminho ao estilo de um tipo de componente como core/helm/eso-aws-fetcher:1.0.0) nunca pode nomear uma entidade do catálogo, seja o que for que o catálogo contenha.
A estrutura é avaliada enquanto o Manifest é composto, antes de qualquer consulta — o veredicto resulta da contagem de separadores numa cadeia de caracteres, pelo que não precisa de catálogo nenhum. Avaliá-la aí é o que torna o diagnóstico honesto: a receita que o valor pretendia indicar está frequentemente presente e corretamente nomeada, e ser informado de que falta leva a procurar a coisa errada. Todos os comandos que resolvem as dependências de uma Release comunicam-na da mesma forma, pelo que não depende de qual se execute.
Mensagem emitida:
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 (referência de receita malformada num valor de mapeamento do Manifest: a chave é mapeada para um valor que contém vários segmentos separados por barras; uma referência de receita aceita nome, nome:versão, capacidade/nome ou capacidade/nome:versão; corrija o valor de mapeamento no Manifest)
A secção features produz a mesma mensagem relativamente à sua própria coordenada, e uma referência de receita de funcionalidade é nomeada como tal.
Um valor cujo segmento de capacidade contém uma fixação de versão — compose:1.2.3/svc:1.0.0 — é recusado da mesma forma, antes de qualquer consulta, pelo que nada é obtido de um registo. Uma fixação pertence à capability que a Recipe declara, onde seleciona qual a versão do plugin que serve essa capacidade que a renderiza; uma referência nomeia a Recipe pela sua capacidade simples (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 (referência de receita malformada num valor de mapeamento do Manifest: a chave é mapeada para um valor que contém uma fixação de versão no seu segmento de capacidade; uma fixação pertence à capacidade que a receita declara, e uma referência de receita nomeia a receita pela sua capacidade simples, como nome, nome:versão, capacidade/nome ou capacidade/nome:versão; corrija o valor de mapeamento no Manifest)
Como corrigir: encurtar o valor de mapeamento para uma estrutura que a gramática aceite. Uma receita é identificada pelo seu próprio metadata.name — opcionalmente com a sua spec.capability como prefixo e a sua versão como sufixo —, nunca pelo caminho do tipo de componente que implementa. A chave do mapeamento é o tipo de componente; o valor do mapeamento é a receita.
Não confundir com um valor bem formado que nomeia uma receita que o catálogo não contém: trata-se de uma entidade realmente ausente, que continua a ser comunicada como tal, nomeando o URI e a entrada de mapeamento que a referia.
Several Recipes implement one Component type (Várias Recipes implementam um mesmo tipo de Component)
Duas ou mais Recipes declaram o mesmo tipo de Component em spec.implements: — duas Recipes de versão exata para um mesmo tipo, ou uma Recipe sem versão ao lado de uma fixada.
Isto não levanta nenhuma interrupção própria, e não é uma ambiguidade que a compilação tenha de resolver. A seleção da Recipe faz-se apenas por mapeamento: nada lê spec.implements: para escolher entre os candidatos, pelo que, por muitas Recipes que implementem um tipo, a que renderiza uma instância é aquela para a qual o Manifest a mapeia. spec.implements: é lido como âncora de coerência — para confirmar que a Recipe que um autor mapeou é uma que declara o tipo sob o qual a mapeou — e como a origem dos candidatos de fixação que uma interrupção sugere. Nunca seleciona.
O que se encontra em vez disso é a interrupção para uma instância que o Manifest não mapeia para nada, e essa interrupção lista cada Recipe que implementa o tipo para que seja possível fixar uma — ver «No Recipe is mapped for a component or feature instance (Nenhuma Recipe está mapeada para uma instância de componente ou de funcionalidade)» mais abaixo. É comunicada da mesma forma quer seja uma Recipe a implementar o tipo, quer sejam cinco, e é por isso que não existe uma condição de ambiguidade separada a consultar.
Como corrigir: adicionar o mapeamento. Uma entrada com chave de tipo encaminha cada instância do tipo; uma entrada com chave de nome encaminha uma instância nomeada e é lida primeiro, pelo que é também a forma de dar a uma instância uma Recipe diferente da das suas irmãs.
Uma Release usa extends: para herdar de uma Release base, mas também declara o seu próprio ponteiro aggregate:. O JSON Schema da Release rejeita esta estrutura na validação do esquema (Camada 1, a verificação do envelope) através de uma restrição allOf: quando extends: está presente, aggregate: é proibido; quando extends: está ausente, tanto aggregate: como manifest: são obrigatórios.
Interrompe-se como uma violação comum do envelope, pelo que o diagnóstico assume a estrutura dessa classe — ver «A classe de falhas do envelope do documento» em error-translation.md — e a constatação aponta para a chave que aqui não é 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 (falha na validação do envelope do documento (Release, no caminho); linha e coluna: spec.aggregate: o valor corresponde a uma estrutura que aqui não é permitida. corrija o documento para que corresponda ao esquema do seu tipo)
Como corrigir: remover o campo aggregate: da Release filha. A herança obriga intencionalmente a filha a implementar a mesma intenção do programador que a Release pai; se for preciso implementar um Aggregate diferente, criar uma nova Release sem extends:.
A feature attached by both the Aggregate and the Release cannot be merged (Uma funcionalidade anexada tanto pelo Aggregate como pela Release não pode ser fundida)
Quando um Manifest local estende um Manifest base com extends, os dois níveis (mapeamento type:, mapeamento name:) são fundidos de forma independente. Dentro de cada nível, as chaves do filho substituem as chaves do pai no nível superior — trata-se de uma substituição superficial, não de uma fusão profunda. Uma entrada do filho para uma dada chave substitui completamente a entrada do pai para essa chave.
Quando o mesmo nome de instância de funcionalidade aparece tanto do lado do Aggregate como do lado da Release com um estado em conflito não fundível (para além da sobreposição de infra permitida), o compilador interrompe-se e posiciona o diagnóstico no anexo que não conseguiu conciliar. As duas declarações em conflito seguem numa ordem fixa — primeiro o tipo que o Aggregate declarou, depois o tipo que a Release declarou — para que se possa saber que documento disse o quê sem abrir ambos.
Mensagem emitida:
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>") (conflito de fusão de funcionalidade: concilie as declarações do Aggregate e da Release para a funcionalidade (Aggregate, no caminho do anexo, tipo declarado pelo Aggregate, tipo declarado pela Release))
O mesmo se aplica a um anexo que uma ligação contém. Quando a entrada de ligação do Aggregate e a entrada da Release para a mesma ligação escrevem ambas um anexo sob um mesmo slot e nomeiam Features diferentes, a compilação interrompe-se na entrada da Release — onde o segundo tipo foi escrito — depois de a composição ser achatada, nomeando ambos os tipos, o slot, a ligação, o socket e o 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. (conflito de fusão de funcionalidade: concilie as declarações do Aggregate e da Release para a funcionalidade (Release, no caminho da ligação, o Aggregate nomeia um tipo, a Release nomeia outro, para o slot, na ligação, através do socket, do componente). Retire o tipo da entrada da Release para que dimensione o anexo que o Aggregate declara, ou nomeie a mesma Feature em ambos os documentos.)
Como corrigir: conciliar as duas declarações. As declarações do lado do Aggregate e do lado da Release da mesma instância de funcionalidade combinam-se por pilar — o Aggregate contribui com values, a Release contribui com infra. Se ambos os lados especificarem o mesmo campo fora dos pilares (como type:), os valores têm de coincidir; corrigir um lado para corresponder ao outro, ou remover a declaração redundante.
Annotation binding does not resolve against its target Feature (A associação de anotação não se resolve em relação à sua Feature de destino)
O campo feature: de uma associação de anotação do Manifest nomeia uma Feature que o catálogo não carrega, ou as listas maps.infra / maps.values da associação declaram caminhos com pontos que o spec.schema da Feature nomeada na realidade não contém. Qualquer uma das condições interrompe o carregamento do espaço de trabalho — a associação sintetizaria anexos de Feature que encaminham valores para caminhos que o ambiente de execução não consegue resolver.
Uma única condição abrange as três formas pelas quais o encaminhamento de uma associação não se resolve, e o diagnóstico indica qual delas se verificou:
Feature não encontrada. O valor de feature: faz referência a um URI de Feature ausente do catálogo carregado.
O esquema da Feature não se resolve. A Feature nomeada é carregada, mas o seu spec.schema: não se resolve numa representação JSON Schema 2020-12 — o conteúdo está mal formado, ou nomeia uma referência entre documentos que não pode ser seguida. Esta variante traz consigo o diagnóstico próprio da falha de resolução, pelo que o motivo pelo qual o esquema não se resolveu pode ler-se na mesma interrupção.
Caminho da associação ausente do esquema de destino. A entrada maps.infra ou maps.values da associação nomeia um caminho com pontos que o spec.schema.<pillar>.<path> da Feature não declara.
Mensagem emitida (variante de Feature não 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") (a associação de anotação não se resolve em relação à sua Feature de destino (Manifest: encaminha para uma Feature que o catálogo desta compilação não contém; corrigir ou publicar a Feature nomeada na associação))
Mensagem emitida (variante em que o esquema não se resolve):
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>) (a associação de anotação não se resolve em relação à sua Feature de destino (Manifest: a associação de anotação encaminha para uma Feature cujo esquema declarado não se resolve))
Esta variante nomeia a Feature e a falha de resolução, e não traz nem a chave da associação nem uma posição na origem — o defeito está no próprio spec.schema: da Feature, que a associação apenas nomeia. A associação responsável encontra-se procurando em mappings.features.annotations o URI de Feature que a mensagem cita.
Mensagem emitida (variante de caminho não encontrado):
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") (a associação de anotação não se resolve em relação à sua Feature de destino (Manifest: encaminha para uma Feature, um pilar e um caminho para o qual essa Feature não declara nenhuma propriedade no seu esquema))
Como corrigir: confirme que o URI feature: da associação existe no catálogo e corresponde ao URI, sensível a maiúsculas e minúsculas, que uma Recipe declara em implements:. Se a variante de caminho não encontrado ocorrer num caminho que o esquema da Feature de facto declara, confirme a grafia do caminho com pontos (sensível a maiúsculas e minúsculas) e o nome do pilar (infra ou values).
A bound annotation value does not conform to the target Feature’s schema (Um valor de anotação associado não está em conformidade com o esquema da Feature de destino)
Uma anotação escrita pelo utilizador encaminha um valor, através de uma associação, para um caminho da Feature de destino — e o valor não satisfaz o subesquema que a Feature declara nesse caminho, ou a Feature não declara aí nenhuma propriedade. A condição avalia-se sobre o valor e não sobre a associação, e é por isso que é distinta da interrupção sobre o destino da associação descrita acima: aquela recusa o que o Manifest declara, esta recusa o que foi escrito através dele.
Validação completa no caminho localizado; salto suave apenas quando o caminho não pode ser localizado. Uma vez localizado o subesquema da subchave associada, o valor é validado contra o conjunto completo de restrições do JSON Schema 2020-12 nesse caminho (tipo, enum, pattern, intervalo numérico, estrutura aninhada de objeto ou array) — um $ref / allOf / oneOf terminal é resolvido contra as definições do esquema e validado, não ignorado. A disciplina do salto suave aplica-se apenas à navegação: quando o percurso encontra uma via de escape ($ref, patternProperties, oneOf/anyOf/allOf, ou additionalProperties com corpo de esquema) num segmento intermédio — antes de chegar à folha associada — o caminho não é resolúvel estaticamente, pelo que o validador continua sem gerar o erro em vez de arriscar uma interrupção falsa; o ambiente de execução continua a ser a superfície de validação dessa associação.
Mensagem emitida (variante de conformidade do 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> (a subchave da anotação não está em conformidade com o esquema da Feature de destino no pilar encaminhado: o valor da subchave da anotação não está em conformidade com o esquema da Feature)
Mensagem emitida (variante de subchave não 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> (a subchave da anotação não está em conformidade com o esquema da Feature de destino no pilar encaminhado: a subchave da anotação não está declarada no esquema da Feature)
A interrupção é gerada sobre a anotação tal como está escrita, antes de ser expandida num anexo de Feature, pelo que o diagnóstico nomeia o documento e o âmbito em que o valor foi escrito — a fronteira e o componente para uma anotação do lado da Release, o caminho do componente para uma do lado do Aggregate — e a chave de anotação de onde provém.
Uma anotação injetada por um plugin de governação é avaliada da mesma forma, e o diagnóstico indica quem a escreveu. Um plugin anexado para injetar anotações define o seu valor num componente da Release, pelo que o valor é verificado exatamente como um que um operador lá tivesse escrito — mas a linha da Release para a qual o diagnóstico aponta é uma que ninguém escreveu. O diagnóstico acrescenta, por isso, qual o plugin que injetou o valor e o papel de governação ao qual está anexado, e a correção está na decisão desse plugin e não na Release.
Como corrigir: corrija o valor associado para que satisfaça o subesquema declarado, ou alargue o esquema dessa propriedade se o valor for legítimo. A variante de subchave não declarada é normalmente antecipada pela interrupção sobre o destino da associação descrita acima; chegar a ela significa que a associação declara o caminho e o esquema da Feature não o contém, pelo que deve corrigir-se aquele dos dois que estiver errado. Quando um operador de composição intermédio torna um caminho não resolúvel e o ambiente de execução o rejeita mais tarde, restrinja o esquema para expor a propriedade diretamente no caminho da associação.
An annotation subkey is not routed by its binding (Uma subchave de anotação não é encaminhada pela sua associação)
Uma anotação escrita pelo utilizador contém subchaves sob uma chave que uma associação de anotação do Manifest reivindica, e uma dessas subchaves é um nome que a associação não encaminha: não consta nem de maps.infra nem de maps.values. Cada subchave é encaminhada por si só, para o caminho de Feature que a associação declara para ela, pelo que uma subchave que a associação não nomeia não tem para onde ir. Expandir a anotação sem ela deixaria fora da compilação um valor escrito pelo utilizador sem que nada fosse assinalado, e uma subchave mal escrita é a causa habitual — por isso a compilação é interrompida, nomeando a subchave, a chave de anotação sob a qual foi escrita e cada subchave que a associação encaminha.
A interrupção é gerada sobre a anotação tal como está escrita, antes de ser expandida num anexo de Feature, tal como acontece com as duas condições vizinhas: «A bound annotation value does not conform to the target Feature’s schema (Um valor de anotação associado não está em conformidade com o esquema da Feature de destino)», acima, recusa uma subchave que a associação encaminha quando a Feature recusa o seu valor, e «An annotation routes through a pillar its authoring side may not use (Uma anotação é encaminhada por um pilar que o seu lado de autoria não pode usar)», abaixo, recusa uma encaminhada pelo pilar errado. Uma chave que nenhuma associação reivindica não se enquadra nesta condição: nada a encaminha, e a compilação deixa-a de lado.
Mensagem emitida, que nomeia o documento e o local onde a anotação foi escrita, a subchave, a chave de anotação e as subchaves que a associação encaminha:
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>") (a subchave da anotação não é encaminhada pela associação da anotação (Release: a subchave, escrita sob a anotação cuja associação encaminha apenas as subchaves indicadas))
Uma anotação escrita num Aggregate é nomeada da mesma forma, no local onde lá foi escrita — (Aggregate <name>, at .spec.subsystems.<subsystem>.annotations, …) para uma escrita num subsistema. A compilação comunica uma anotação do lado da Release sob uma etiqueta OPS_ERROR e uma do lado do Aggregate sob uma etiqueta DEVELOPER_ERROR, consoante o documento que a escreveu.
Como corrigir: compare a subchave com as que a mensagem enumera. Quando se trata de um erro ortográfico, corrija-a para a subchave que a associação encaminha. Quando o valor se destina a chegar à Feature, a associação tem de o encaminhar: acrescente o caminho a maps.infra ou maps.values da associação no Manifest — um caminho que o esquema da Feature declare — ou remova a subchave da anotação.
A bare annotation value does not route to exactly one path of its binding (Um valor de anotação simples não é encaminhado para exatamente um caminho da sua associação)
Uma anotação escrita como valor simples — feature.aggrega.ai/monitoring: "30s" em vez de um mapa de subchaves — não nomeia nenhuma subchave, pelo que nada nela indica qual o caminho de Feature que preenche. É colocada no único caminho que a associação declara, contando maps.infra e maps.values em conjunto. Uma associação que declara mais de um caminho deixa ao valor vários destinos possíveis e nada para escolher entre eles, pelo que a compilação é interrompida em vez de escolher um. A contagem abrange as duas listas, pelo que uma associação que encaminha um caminho por infra e outro por values recusa um valor simples seja qual for o documento em que esteja escrito.
A interrupção é gerada sobre a anotação tal como está escrita, antes de ser expandida num anexo de Feature, tal como acontece com as condições vizinhas, pelo que o diagnóstico nomeia o documento e o local onde o valor foi escrito. A verificação faz-se uma vez por cada anotação escrita: um valor escrito numa fronteira ou num subsistema é recusado aí, uma única vez, quer um componente nele contido o aproveite quer não. Cada valor deste tipo na compilação é comunicado, não apenas o primeiro. A compilação comunica uma anotação do lado da Release sob uma etiqueta OPS_ERROR e uma do lado do Aggregate sob uma etiqueta DEVELOPER_ERROR, consoante o documento que a escreveu. A condição é a scalar annotation value does not route to exactly one path of its binding, que é o que aggrega explain imprime para o seu código.
Mensagem emitida, que nomeia o documento e o local onde a anotação foi escrita, a chave de anotação, o valor e os caminhos que a associação encaminha:
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>") (um valor de anotação escalar não é encaminhado para exatamente um caminho da sua associação (Release: a chave contém um valor simples, cuja associação encaminha os caminhos indicados))
Um valor vazio não escreve nada, pelo que é colocado onde quer que uma das duas listas contenha um único caminho, e é recusado apenas onde nenhuma delas o contém. Uma associação que não declara nenhum caminho é recusada quando o Manifest é carregado, porque o esquema do Manifest exige um, pelo que uma compilação não chega a esta condição por essa via.
Uma anotação injetada por um plugin de governação é avaliada da mesma forma, e o seu diagnóstico acrescenta qual o plugin que injetou o valor e o papel de governação ao qual está anexado, tal como fazem as condições vizinhas.
Como corrigir: escreva a anotação como um mapa que nomeie a subchave a que cada valor se destina — feature.aggrega.ai/monitoring: {interval: 30s} — para que cada valor seja encaminhado pelo seu próprio nome; ou atribua ao valor único uma associação própria, sob outra chave de anotação, que declare apenas o caminho que preenche.
An annotation routes through a pillar its authoring side may not use (Uma anotação é encaminhada por um pilar que o seu lado de autoria não pode usar)
As anotações estão repartidas por lado de autoria, e a repartição é a mesma que rege todos os outros pilares escritos: uma anotação do lado do Aggregate só pode ser encaminhada por um caminho da associação que aponte para values, e uma anotação do lado da Release só por um caminho que aponte para infra. Qualquer outra combinação provoca uma interrupção.
A repartição é o que impede que o atalho das anotações se torne uma forma de escrever o pilar do outro lado. A anotação de um programador contribui com values; a de um operador contribui com o dimensionamento infra. Uma associação que declara caminhos nos dois pilares não é, em si, um erro — cada lado encaminha o subconjunto que lhe é permitido, e os caminhos do outro lado simplesmente não são alcançáveis a partir dele.
Uma associação que declara um mesmo caminho em ambas as listas de pilares é o caso que mais frequentemente chega a esta interrupção. O critério de desempate do encaminhamento envia esse caminho por infra, o que o torna inalcançável a partir do lado do Aggregate, e uma anotação do lado do Aggregate encaminhada para ele é interrompida aqui. O aviso que assinala essa estrutura de associação antes de uma compilação chegar a esta interrupção está descrito em warnings.md.
Mensagem emitida:
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> (a anotação é encaminhada por um pilar que o seu lado de autoria não pode usar: a anotação é encaminhada por um pilar num caminho, mas as anotações desse lado só podem ser encaminhadas pelo pilar permitido)
Uma anotação injetada por um plugin de governação está num componente da Release, pelo que é uma anotação do lado da Release e aplica-se-lhe a mesma repartição. O seu diagnóstico acrescenta qual o plugin que a injetou e o papel de governação ao qual está anexado, porque a chave da Release para a qual aponta é uma que ninguém escreveu.
Como corrigir: encaminhe a anotação a partir do lado cujo pilar é o destino da associação, ou acrescente uma associação — sob a sua própria chave de anotação — cujos caminhos apontem para o pilar permitido ao lado de autoria. Quando uma associação declara o mesmo caminho nas duas listas de pilares, divida-a em duas associações para que cada lado tenha um caminho que consiga alcançar. Quando o diagnóstico nomeia um plugin que injeta, a anotação provém da decisão desse plugin: corrija o plugin, ou a associação sob a qual injeta.
Authored values or infra do not conform to the declared schema (Os values ou infra escritos não estão em conformidade com o esquema declarado)
Os values: ou infra: resolvidos de uma instância de componente — ou de uma Feature anexada — não estão em conformidade com o esquema de catálogo declarado. A compilação valida cada pilar contra o seu esquema declarado antes da renderização, pelo que uma chave mal escrita, um valor de tipo errado, um número fora do intervalo ou um campo obrigatório em falta é detetado na origem, em vez de produzir um manifesto defeituoso no momento da implementação.
A verificação abrange as restrições de esquema habituais: um valor do tipo errado (uma cadeia onde o esquema declara um inteiro), um valor fora de um intervalo declarado ou de um enum, um valor que não satisfaz um pattern declarado, uma cadeia que não é uma instância válida do seu format declarado — um dos formatos com nome — e um campo obrigatório que não foi fornecido. Uma falha de formato indica a palavra-chave e inclui o valor, o formato e o que está errado — tal como aggrega pull e aggrega validate --release a apresentam para um campo uri a que é dado ::::, "format", "value \"::::\" is not a valid uri: a URI begins with a scheme followed by a colon, such as https:". Tem em conta os valores predefinidos: um campo a que o esquema atribui um default: é considerado fornecido mesmo quando é omitido, pelo que um campo obrigatório com valor predefinido nunca dispara a verificação «em falta».
O pilar values é a superfície de autoria do programador. É validado de forma fechada — uma propriedade que o esquema não declara é rejeitada como provável gralha. Um esquema de values que se compõe dentro do próprio documento (um #/$defs$ref local ou allOf) é resolvido e validado face a esse contexto de definições.
O pilar infra é a superfície de dimensionamento do operador e só é verificado quando o Component declara um pilar schema.infra — essa declaração é o contrato a que o componente adere. É validado de forma fechada face a essa declaração e a nada mais, exatamente como o pilar values é validado face a schema.values: uma chave que o Component não declara é rejeitada como gralha, e uma chave que declara tem o tipo e o intervalo impostos. Um componente que pretende que uma chave sobreposta pelo fornecedor, como replicas, seja validada declara essa chave no seu próprio schema.infra; o vocabulário aceite por um fornecedor é alcançado através do valuesMapping da sua Recipe, em vez de ser sobreposto à superfície infra escrita.
A verificação mede o dimensionamento de cada componente que a Release colocou, e uma entrada que não escreve nenhum bloco infra: também é medida: um bloco ausente é um bloco vazio, pelo que uma chave required: sem default: é comunicada como em falta — que é precisamente o caso que tal chave existe para detetar. Contam as duas formas de colocar um componente. Nomeá-lo sob os components de uma fronteira coloca-o, e o mesmo faz encaminhar sob aggregates o submódulo que o contribui; uma entrada de encaminhamento coloca componentes sem dizer nada sobre nenhum deles, pelo que um componente colocado dessa forma parte de um bloco de dimensionamento vazio e uma chave required: sem valor predefinido no seu tipo é comunicada como em falta. Um componente que a Release não coloca por nenhuma das duas vias não é de todo medido face a este contrato. Tem um defeito diferente, e a compilação comunica esse em seu lugar: um componente que não está colocado em nenhuma fronteira, com as duas formas de o colocar indicadas.
O contrato aplica-se a um componente onde quer que tenha sido escrito: um componente que um submódulo contribui é medido exatamente como um que o próprio Aggregate da Release declara. A profundidade a que um componente está aninhado não altera quais das restrições do seu tipo se aplicam.
Os anexos de Feature são validados da mesma forma, face ao schema.values / schema.infra declarados pela Feature anexada. Os anexos partilham uma única superfície, pelo que uma Feature de credenciais — uma com a etiqueta feature.aggrega.ai/kind: secret — é medida face ao seu próprio esquema declarado exatamente como qualquer outro anexo. O valor verificado é o resultado efetivo da fusão depois de os valores dos anexos se propagarem em cascata pelos âmbitos (componente, subsistema, fronteira e específico do componente) — pelo que um valor introduzido legalmente num âmbito, mas substituído por um valor ilegal num âmbito mais específico, é detetado no resultado da fusão, não no fragmento. Um anexo cujo tipo não declara nenhum esquema não é validado; o infra de um anexo é validado face ao próprio schema.infra do anexo (um anexo é uma sobreposição e não transporta nenhuma união de fornecedores).
A constatação de um anexo é comunicada no documento que escreveu o pilar com defeito, sob o nome desse documento, e atribuída ao seu autor. Os seus values são comunicados no bloco do Aggregate que os escreveu — a própria entrada features: do componente, .spec.components.<component>.features.<attachment>.values.<field>, antes do bloco de um subsistema que alcança o componente — como defeito do programador. O seu infra é comunicado no bloco da Release que o escreveu — a entrada da Release para o componente, sob a fronteira que o nomeia, antes do próprio bloco features: da fronteira — como defeito do operador. Um pilar que o documento a que pertence não escreveu é comunicado onde o próprio anexo foi escrito, que é onde o seu type é nomeado. Assim, um anexo que só a Release faz, que não transporta values, comunica um campo que os values da sua Feature exigem na entrada da Release e como defeito do operador, num caminho que a Release contém — a entrada do componente, ou o bloco features: da fronteira para um anexo que a fronteira faz para cada componente sob ela:
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))
O mesmo anexo escrito no componente no Aggregate comunica [DEVELOPER_ERROR E0168] em .spec.components.app.features.check.values.schema, sob o nome do Aggregate. Um editor mostra cada um no documento que o escreveu, na chave mais profunda desse caminho que o documento contém.
Um anexo que uma ligação transporta é medido da mesma forma e comunicado na entrada de ligação do documento que escreveu o pilar com defeito, em vez de no próprio bloco features: do componente, que não o contém. Os seus values são comunicados na entrada de ligação do Aggregate, .spec.components.<component>.uses.<socket>.<alias>.features.<slot>.values.<field> — no próprio documento do submódulo, para um componente que um submódulo contribui — e o seu infra na entrada da Release para essa ligação, sob a fronteira que nomeia o componente quando a Release nomeia fronteiras. Um anexo que só a Release faz é comunicado na entrada da Release para os dois pilares: tal anexo não transporta values, pelo que uma Feature cujos values exigem um campo comunica-o como em falta aí, na entrada que o operador escreveu.
A configuração de ligação por aresta é validada da mesma forma face ao contrato por aresta do socket: os values de uma aresta escritos pelo programador face ao valueSchema do socket, e o infra de uma aresta escrito pelo operador (a partir de uma Release) face ao infraSchema do socket. Um socket que não declara nenhum esquema por aresta para um pilar não aceita nenhuma configuração validada para ele (omissão = nenhum contrato, nada a verificar). O diagnóstico identifica a aresta por consumidor, socket e alias. Num componente que o próprio Aggregate da Release declara, o infra do operador é medido para cada entrada que a Release escreve para uma das suas ligações — incluindo uma entrada que não transporta infra, que é como uma chave required: sem valor predefinido é comunicada como em falta — e comunicado nessa entrada na Release, sob a fronteira que nomeia o componente quando a Release nomeia fronteiras, que é onde o operador o edita; os values do programador são comunicados na entrada de ligação no Aggregate.
Uma folha declarada sensitive: true tem a sua falha de restrição retida. O texto da falha cita o valor em causa, e um diagnóstico de compilação é lido por qualquer pessoa que acompanhe a compilação, pelo que numa folha declarada sensível — ou em qualquer ponto dentro de um objeto declarado sensível — o <constraint failure> abaixo apresenta <redacted> em seu lugar. O mesmo se aplica numa posição que contém uma folha declarada sensível abaixo dela, incluindo o próprio pilar: um $ref escrito ao lado de outras palavras-chave é verificado por inteiro onde está escrito, pelo que uma falha dentro da definição que nomeia é comunicada nessa posição e, de outro modo, citaria o valor da folha. A entidade, o caminho do campo, o pilar e o nome do contrato continuam todos indicados, pelo que o diagnóstico continua a indicar onde está a falha; só o texto que reproduziria o valor é retirado. A sensibilidade é lida por pilar, pelo que uma folha com o mesmo nome em values e infra só é retida no pilar que a declara.
Mensagem emitida:
authored pillar does not conform to its declared schema (Aggregate <name>, at .spec.components.<component>.values.<field>, “values.<field>”, “<keyword>”, “<constraint failure>”) (o pilar escrito não está em conformidade com o seu 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>”) (o pilar escrito não está em conformidade com o seu 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>) (o pilar escrito não está em conformidade com o seu esquema declarado: o pilar values não está em conformidade com o esquema da 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>) (o pilar escrito não está em conformidade com o seu esquema declarado: o pilar infra não está em conformidade com o esquema da 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>) (o pilar escrito não está em conformidade com o seu esquema declarado: o pilar values não está em conformidade com o esquema da 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>”) (o pilar escrito não está em conformidade com o seu 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>) (o pilar escrito não está em conformidade com o seu esquema declarado: o pilar values não está em conformidade com o esquema da 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>) (o pilar escrito não está em conformidade com o seu esquema declarado: o pilar values não está em conformidade com o esquema da 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>”) (o pilar escrito não está em conformidade com o seu esquema declarado)
Como corrigir: corrija o valor em causa para que satisfaça o esquema declarado ou — se o valor for legítimo — alargue o esquema que o declara (o schema.values/schema.infra do Component, ou o da Feature anexada) para que o declare. Inspecione o esquema declarado de um Component com aggrega inspect <component-type> para ver os tipos exatos, os intervalos, os valores predefinidos e os campos obrigatórios que cada pilar espera.
A declared schema contract cannot be read as a schema (Um contrato de esquema declarado não pode ser lido como esquema)
Um Component ou uma Feature declara um contrato de esquema que não fornece nada face ao qual validar, pelo que a configuração que cobre é medida face a nada. Três contratos podem transportar o defeito, cada um escrito no seu próprio campo: o próprio spec.schema da entidade e os dois contratos por aresta que um socket de dependência declara — valueSchema para o lado do programador de uma ligação e infraSchema para o do operador. Uma entrada de SchemaLibrary, que esses contratos podem referenciar, também pode transportar o terceiro dos defeitos abaixo; a forma como esse caso é comunicado é explicada mais adiante.
Três defeitos levam a esta interrupção, e dois deles passam facilmente despercebidos porque o contrato parece correto. Um contrato de socket pode nem sequer compilar para JSON Schema 2020-12 — uma palavra-chave mal escrita é a causa mais comum; um spec.schema próprio de uma entidade que não compila é comunicado, em vez disso, sob a condição de forma compacta que a sua compilação encontrou (E0120 para uma palavra-chave desconhecida, E0116 para uma restrição que o seu tipo não aceita). Ou pode compilar sem problemas e mesmo assim não construir nenhum validador: o corpo é legível como forma compacta e não é um esquema face ao qual se possa validar algo, como um escalar simples onde deveria estar o esquema de uma propriedade (items: nonsense). Ou pode estar bem formado em todos os outros aspetos e indicar um formato fora do conjunto suportado — format: password, ou um erro de grafia como format: emial — que é recusado em vez de ser lido como uma restrição que nada verifica, quer algum valor chegue ao campo, quer não; os nomes que um format pode assumir estão listados em Formatos com nome. Os três são uma única condição, porque o remédio é o mesmo e deixar passar qualquer um deles tem a mesma consequência.
Não declarar nenhum contrato e declarar um que não pode ser lido são situações diferentes, e a compilação trata-as de forma diferente. Um campo que não declara nada é ignorado: a conformidade por pilar e por aresta é opcional, pelo que um socket que não restringe nenhum dos dois pilares é autoria comum e não gera nenhum diagnóstico. Um campo que declara algo ilegível é recusado. Deixá-lo passar deixaria sem validação toda a carga útil que cobre enquanto a compilação comunicava sucesso — uma verificação que deixou de ser executada sem nada que diga que deixou. Assim, é a recusa que mantém os dois separados: o silêncio significa que não havia nada a verificar, e uma interrupção significa que havia algo e não foi possível lê-lo.
A recusa indica a entidade que declarou o contrato, e não o documento que escreveu a configuração, porque é aí que a correção deve ser feita. Um autor de Aggregate a quem é entregue um tipo de componente cujo contrato não pode ser lido não tem nada a alterar no seu próprio ficheiro. A recusa surge quando o catálogo é lido, onde a entidade declarante, o pilar, o campo escrito e a linha de origem são todos conhecidos — pelo que o mesmo defeito é comunicado de forma idêntica, quer seja alcançado a partir de uma compilação, de aggrega validate ou da ferramenta de compilação que aggrega mcp expõe. Um contrato que a entidade lê através de $import: — o seu spec.schema inteiro, um dos seus pilares ou o contrato de um socket — é comunicado no ficheiro importado: a localização indica esse ficheiro e a linha nele onde o fragmento está escrito, enquanto a mensagem continua a indicar a entidade e o campo que declarou o contrato. As interrupções de forma compacta que o próprio spec.schema de uma entidade encontra são localizadas da mesma forma.
Uma entrada de SchemaLibrary que indica um formato fora do conjunto suportado chega a esta interrupção quando a sua biblioteca é lida, e a recusa indica a biblioteca e a entrada e aponta para a entrada no ficheiro da biblioteca. aggrega validate sobre o catálogo inteiro lê todas as bibliotecas, pelo que comunica a entrada quer algum esquema a referencie, quer não, enquanto uma Release cuja resolução de dependências nunca alcança a biblioteca não a lê. Uma Release cujos esquemas alcançam de facto a entrada através de um $ref: também é recusada, mas a recusa não indica o formato: aggrega pull comunica que a biblioteca não foi encontrada no catálogo (E0114), e aggrega validate --release comunica que o destino da referência não foi encontrado (E0121). Execute aggrega validate sobre o catálogo para ver a entrada e o nome com defeito.
A mensagem transporta a falha tal como a ferramenta que a encontrou a comunicou: para uma falha de compilação, a chave dentro do contrato, a linha de origem e a palavra-chave em causa; para um corpo que não constrói nenhum validador, a posição que o validador rejeitou; para um nome de formato fora do conjunto suportado, o campo, a palavra-chave format, o nome tal como foi escrito e cada nome suportado. Um $ref: entre documentos num contrato de socket cuja entrada de SchemaLibrary não está no fecho carregado chega à mesma interrupção quando aggrega validate verifica a entidade ou a Release; no próprio spec.schema de uma entidade, é comunicado tal como descreve «A $ref: is not written in a form the compiler can resolve (Uma referência não está escrita numa forma que o compilador consiga resolver)» acima. aggrega pull lê os dois locais para as bibliotecas de que uma Release precisa, pelo que uma biblioteca ausente do catálogo interrompe o pull mais cedo, tal como descreve «A reference names no entity the catalog holds (Uma referência não nomeia nenhuma entidade que o catálogo contenha)» (E0114), seja qual for dos dois que a referencie — e uma biblioteca que o catálogo contém é fixada no ficheiro de bloqueio para qualquer um deles.
Uma restrição bem formada ao lado de uma ilegível não é aplicada. Um contrato é lido como um único documento, pelo que um único fragmento ilegível desativa todas as restrições declaradas a seu lado. É por isso que a interrupção vale mais do que as restrições que custa: a alternativa é um contrato que parece aplicado, se lê como aplicado e não aplica nada.
Mensagem emitida, que nomeia a entidade com a sua versão e o campo que declara o contrato, depois o pilar que esse contrato restringe, depois a falha — aqui um contrato de socket com uma palavra-chave 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 (o contrato de esquema declarado não pôde ser compilado num esquema utilizável, pelo que nada foi validado com base nele: corrija o contrato onde está declarado, ou remova-o se a configuração que abrange não precisar de validação. Component: spec.usesSchema.valueSchema do socket declara um esquema a partir do qual não é possível construir nenhum validador, pelo que os valores que restringe ficariam por medir: compactform na chave e na linha indicadas: palavra-chave desconhecida)
e um nome de formato fora do conjunto suportado no pilar values de um 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) (o contrato de esquema declarado não pôde ser compilado num esquema utilizável, pelo que nada foi validado com base nele: corrija o contrato onde está declarado, ou remova-o se a configuração que abrange não precisar de validação. Component: spec.schema.values declara um esquema a partir do qual não é possível construir nenhum validador, pelo que os valores que restringe ficariam por medir: validator/jsonschema: a resolução do esquema falhou (no campo sob values, palavra-chave format: o formato não é suportado; os formatos suportados são email, uri, hostname, ipv4, ipv6, uuid, date-time, date))
Uma Feature é designada como Feature "<name>:<version>", o contrato de um socket pelo seu próprio campo, como spec.usesSchema.<socket>.infraSchema, e o pilar por aquele que o contrato restringe — values, infra ou provides. aggrega validate, quando recebe o ficheiro próprio da entidade, nomeia a entidade sem a sua versão. Uma entrada de SchemaLibrary é designada pela sua biblioteca e pela sua 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) (o contrato de esquema declarado não pôde ser compilado num esquema utilizável, pelo que nada foi validado com base nele: corrija o contrato onde está declarado, ou remova-o se a configuração que abrange não precisar de validação. SchemaLibrary: o esquema nomeia um formato que nenhum validador consegue verificar, pelo que os valores que restringe ficariam por medir: validator/jsonschema: a resolução do esquema falhou (no campo indicado, palavra-chave format: o formato não é suportado; os formatos suportados são email, uri, hostname, ipv4, ipv6, uuid, date-time, date))
Como corrigir: abra o campo que o diagnóstico nomeia e corrija o fragmento na chave e na linha indicadas — na maior parte dos casos uma palavra-chave mal escrita, a verificar face ao vocabulário de palavras-chave em vocabulary/compact-form-authoring.md, ou um valor escrito onde deve estar um esquema aninhado. Quando a falha nomeia um formato não suportado, escreva um dos formatos com nome ou remova o format:; um campo que contém material secreto declara antes sensitive: true, uma vez que password não é um formato. Para uma entrada de SchemaLibrary, a correção faz-se no ficheiro de biblioteca que o diagnóstico nomeia. Quando a falha nomeia uma referência entre documentos, confirme que a entrada de SchemaLibrary existe e que a biblioteca é alcançável a partir do fecho de dependências da Release. Se a configuração que esse campo abrange não precisar realmente de validação, remova o campo em vez de deixar um contrato que nada consegue ler.
Recipe source: is an empty string (O campo source da Recipe é uma cadeia vazia)
Uma Recipe declara source: "" — uma cadeia vazia. O source: de uma Recipe escolhe entre dois modos de autoria: o modo sourceless, em que não existe nenhum artefacto externo e a saída é produzida inteiramente a partir dos outros tipos de entrada da Recipe, e o modo sourced, em que source: nomeia um chart, um módulo ou um ficheiro externo a partir do qual renderizar. Omitir o campo seleciona o primeiro, um valor não vazio seleciona o segundo e uma cadeia vazia não seleciona nenhum dos dois — pelo que é uma ambiguidade e não um valor com significado. Um source: escrito como null equivale a omiti-lo.
A Recipe é recusada em vez de o compilador escolher uma das duas leituras em nome de quem a escreveu. A forma mais comum de escrever um source: vazio é apagar um URI e deixar a chave: pretendia-se o modo sourced, e admitir a cadeia vazia como sourceless entregaria o componente sem o artefacto e nunca diria qual das duas leituras adotou.
Esta regra é verificada quando a Recipe é carregada, lendo o valor exatamente como foi escrito, pelo que todos os comandos que carregam a Recipe indicam esta condição antes de qualquer coisa tentar usar o valor vazio. aggrega validate sobre o ficheiro da Recipe recusa-a; aggrega pull, uma compilação, aggrega validate --release e a ferramenta de compilação que aggrega mcp expõe reportam-na para uma Release que alcança a Recipe, antes da referência à Recipe que, por causa dela, deixou de poder ser resolvida. Um pull indica, portanto, esta condição em vez de reportar a referência vazia como uma cujo tipo de source não consegue determinar. É verificada antes das regras que leem se um source está declarado, pelo que uma Recipe cujo source: está vazio é informada sobre o source: e não sobre um valuesMapping sem nada para sobrepor ou sobre um tipo de entrada em falta.
Mensagem emitida, posicionada no ficheiro da Recipe em que o source: vazio foi escrito e na chave dentro dele — .spec.source — e não num componente que associa a Recipe, porque a entrada é partilhada por todos os componentes que o fazem:
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 (o campo source da receita é uma cadeia vazia, que não nomeia nem o modo sourceless nem o modo sourced. omita o campo source para o modo sourceless, ou indique um caminho ou URI não vazio para o modo sourced)
A compilação imprime a linha sob uma etiqueta CATALOG_ERROR com o código curto desta condição, E0251, e o ficheiro da Recipe ao lado.
Como corrigir: omita totalmente o campo source: (ou defina-o como null) se a Recipe for sourceless, ou forneça um caminho / URI / objeto source estruturado não vazio se a Recipe for sourced.
No Recipe is mapped for a component or feature instance (Nenhuma Recipe está mapeada para uma instância de componente ou de funcionalidade)
O tipo de uma instância não tem nenhum mapeamento do Manifest que se resolva numa Recipe que o catálogo contenha. A seleção da Recipe é apenas por mapeamento: o compilador nunca escolhe uma Recipe lendo spec.implements: e escolhendo entre os candidatos, pelo que um tipo sem mapeamento interrompe a compilação, independentemente de quantas Recipes o implementem. implements informa a escolha; o autor faz a escolha; o Manifest regista-a.
A mesma condição abrange um mapeamento que existe mas não leva a lado nenhum — um valor numa estrutura de referência aceite que nomeia uma Recipe que o catálogo não contém, incluindo uma presente com uma versão diferente da que o valor fixa, e uma cujo nome simples é oferecido por duas capacidades ao mesmo tempo. Nenhuma se resolve numa Recipe que se possa dizer que o autor escolheu. Um valor de mapeamento cuja estrutura nenhuma referência consegue exprimir é comunicado à parte, em «Manifest mapping value is not a shape a recipe reference accepts (O valor de mapeamento do Manifest não tem uma estrutura que uma referência de receita aceite)» acima, de modo que a afirmação de que uma entidade está ausente só é feita sobre uma referência que se poderia ter resolvido.
Mensagens emitidas, para uma instância de componente. Quando existe um mapeamento e este nomeia 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 (nenhuma receita resolvida para a instância de componente/funcionalidade: adicione um mapeamento explícito do Manifest para o seu tipo (Manifest, com a instância, o seu tipo e a receita para a qual está mapeada). corrija o valor do mapeamento no Manifest, ou publique a receita que este nomeia)
Quando não existe nenhum mapeamento e estão presentes Recipes que implementam o tipo, estas são listadas como os candidatos a fixar:
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 (nenhuma receita resolvida para a instância de componente/funcionalidade: adicione um mapeamento explícito do Manifest para o seu tipo (Manifest, com a instância, o seu tipo e as receitas que o implementam). fixe uma delas no Manifest)
E quando nada implementa o tipo, não há nada a listar:
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 (nenhuma receita resolvida para a instância de componente/funcionalidade: adicione um mapeamento explícito do Manifest para o seu tipo (Manifest, com a instância e o seu tipo). nenhuma receita do catálogo implementa este tipo; escreva uma e depois mapeie o tipo para ela)
Num espaço de trabalho que não indica nenhum diretório de catálogo, as Recipes pesquisadas são apenas as que o lockfile fixa: as de um registo não são listadas, e um Manifest que não mapeia nenhuma para o tipo não fixa nenhuma. Nesse caso, quando nenhuma Recipe fixada implementa o tipo, a ausência é afirmada em relação ao que está fixado, e não ao catálogo, e a mensagem di-lo:
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 (nenhuma receita resolvida para a instância de componente/funcionalidade: adicionar no Manifest um mapeamento explícito para o seu tipo (Manifest, na posição, para a instância e do tipo indicados). nenhuma receita fixada pelo lockfile implementa este tipo; sem diretório de catálogo, as receitas pesquisadas são apenas as que o lockfile fixa, não as de um registo; fixar no Manifest uma que um registo publique, ou escrever uma e depois mapear o tipo para ela)
A um tipo que o Aggregate escreve sem versão são oferecidas as Recipes que implementam a versão com que a compilação o compila — a versão mais alta desse Component que o catálogo contém. A uma instância de core/datastore/postgres, com o catálogo a conter esse Component em 1.0.0, é oferecida toda a Recipe que declare spec.implements: core/datastore/postgres:1.0.0, bem como qualquer uma que declare o tipo sem versão ou um intervalo caret que admita 1.0.0. A um tipo do qual o catálogo não contém nenhum Component são oferecidas apenas as Recipes que declaram esse próprio tipo sem versão.
Uma instância de funcionalidade reporta estes casos numa forma própria, cada um após a frase da condição. Um tipo de funcionalidade que o Aggregate escreve sem versão é correspondido da mesma forma que um tipo de componente, na versão em que a compilação o compila — a versão mais alta dessa Feature que o catálogo contém —, e uma mensagem que indica <type>:<version> indica o tipo nessa versão, que é o que foi procurado no catálogo. Quando a Recipe para a qual o componente de uma associação está mapeado é conhecida, as FeatureRecipes distinguem-se pela capacidade à qual essa Recipe se vincula: as que se vinculam à capacidade do componente são propostas primeiro, e uma FeatureRecipe que se vincula a outra capacidade continua a ser renderizada, como saída própria ao lado da do componente em vez de dentro dela; assim, quando nenhuma se vincula à capacidade do componente, são essas as propostas. Um mapeamento que não leva a lado nenhum diz feature "<instance>" (type "<type>"): the Manifest maps it to feature recipe "<uri>", which is not in the catalog. Quando há FeatureRecipes que implementam o tipo para a capacidade do componente, só essas são listadas: feature "<instance>" (type "<type>"); feature recipes implementing it for capability "<capability>", the capability its component's Recipe binds to: [<recipe-uris>]; pin one in the Manifest. Quando o implementam apenas para outras 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. Quando nenhuma implementa o tipo: feature "<instance>" (type "<type>"); no feature recipe in the catalog implements <type>:<version>; write one, then map the type to it. E quando a capacidade não é conhecida — o próprio mapeamento do componente não se resolve em nenhuma Recipe, o que é reportado à parte, ou a associação está escrita numa fronteira, cujos componentes podem ser renderizados através de várias capacidades —, é listada cada implementação: feature "<instance>" (type "<type>"); feature recipes implementing it: [<recipe-uris>]; pin one in the Manifest. Num espaço de trabalho que não indica nenhum diretório de catálogo, as FeatureRecipes pesquisadas são apenas as que o lockfile fixa: as de um registo não são listadas, e um Manifest que não mapeia nenhuma para o tipo não fixa nenhuma. Nesse caso, as afirmações de ausência são feitas em relação ao que está fixado, e não ao catálogo, e dizem-no. Quando nenhuma implementa o tipo: feature "<instance>" (type "<type>"); no feature recipe the lockfile pins implements <type>:<version> for capability "<capability>", the capability its component's Recipe binds to; with no catalog directory, the feature recipes searched are only those the lockfile pins, not a registry's; pin one a registry publishes in the Manifest, where one for another capability renders as its own output beside the component's, or write one for "<capability>", then map the type to it — e quando a capacidade não é conhecida, a mensagem não indica nenhuma e termina com pin one a registry publishes in the Manifest, or write one, then map the type to it. Quando há FeatureRecipes fixadas que o implementam apenas para outras capacidades, a mensagem para esse caso diz no feature recipe the lockfile pins implements em vez de no feature recipe in the catalog implements, com a mesma oração após a capacidade.
Como corrigir: adicione o mapeamento que a mensagem pede, sob spec.mappings.components.type no Manifest, com o tipo de componente como chave e a Recipe como valor. Quando a mensagem lista candidatos, escolha um deles — essa lista é exatamente o conjunto das Recipes que declaram implementar o tipo na versão para a qual a compilação o resolve. Quando nomeia uma Recipe que não está no catálogo, corrija o valor ou adicione a Recipe a um diretório de catálogo que a compilação leia; uma versão no valor tem de corresponder a uma versão que o catálogo contenha. Quando nada implementa o tipo, a peça em falta é a própria Recipe. Quando a mensagem diz que as receitas ou receitas de funcionalidade pesquisadas são apenas as que o lockfile fixa, o espaço de trabalho não lê nenhum diretório de catálogo, pelo que um registo pode ainda assim publicar uma Recipe ou FeatureRecipe que implemente o tipo: mapear o tipo para ela no Manifest é o que leva o pull a obtê-la e a fixá-la.
A Manifest name mapping names nothing in the build (Um mapeamento por nome do Manifest não nomeia nada na compilação)
Uma chave sob spec.mappings.components.name ou spec.mappings.features.name não nomeia nenhuma instância de componente, nem nenhum anexo, que a compilação contenha. O nível name é comparado com o nome exato do que está a ser realizado: uma chave components.name com o nome de uma instância de componente tal como o Aggregate o escreve, e uma chave features.name com o nome próprio de um anexo — a chave sob a qual está escrito nos features: de um componente, ou <alias>.<slot> para um anexo escrito numa ligação — nunca com o nome do componente em que o anexo se encontra. Uma chave que não nomeia nada nunca seria consultada: cada instância a que se destinava seria resolvida através do nível type, e a compilação terminaria sem uma palavra sobre a entrada que ignorou. Por isso, a compilação interrompe-se, antes de qualquer renderização.
A mensagem nomeia o Manifest, a chave e a secção em que está escrita, os nomes desse género que a compilação efetivamente contém — restringidos ao tipo que a Recipe ou a FeatureRecipe da entrada implementa, quando esse tipo é conhecido e a compilação contém um dele — e, quando o consegue determinar, o nome que provavelmente se pretendia: para uma chave features.name que é o nome de um componente, os anexos desse tipo que o componente tem; para uma chave components.name que é o nome de um anexo, o componente que o tem; e, caso contrário, um nome a uma edição de distância.
Mensagem emitida, para uma chave features.name escrita como o nome do componente em que o anexo se encontra:
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>"? (a chave de um mapeamento por nome do Manifest não nomeia nenhuma instância de componente nem anexo nesta compilação, pelo que a entrada não associa nada: Manifest, chave sob mappings.features.name: nenhum anexo nesta compilação tem esse nome; uma chave features.name nomeia um anexo pelo seu próprio nome — a chave sob a qual está escrito nos features de um componente, ou o alias e o slot para um anexo escrito numa ligação — nunca o componente a que está anexado; anexos do tipo indicado nesta compilação: listados; esse nome é um componente, e uma chave features.name nomeia o anexo e não o componente a que está anexado — pretendia dizer o anexo sugerido?)
E para uma chave components.name a uma edição de distância do nome de uma instância:
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>"? (a chave de um mapeamento por nome do Manifest não nomeia nenhuma instância de componente nem anexo nesta compilação, pelo que a entrada não associa nada: Manifest, chave sob mappings.components.name: nenhuma instância de componente nesta compilação tem esse nome; uma chave components.name nomeia uma instância de componente exatamente como o Aggregate a escreve; instâncias de componente do tipo indicado nesta compilação: listadas; pretendia dizer a instância sugerida?)
Cada chave que não nomeia nada é comunicada numa única compilação, pela ordem em que o Manifest as escreve.
Como corrigir: mude o nome da chave para o nome que a mensagem sugere, ou para um dos nomes que lista — para um anexo, o nome sob o qual está escrito, não o do seu componente. Se a entrada já não for pretendida, remova-a; as instâncias desse tipo passam então a ser resolvidas através do nível type.
A Manifest maps two version-distinct keys onto one type (Um Manifest mapeia duas chaves de versões distintas para um mesmo tipo)
Uma pesquisa por tipo correspondeu a mais de uma chave de mapeamento do Manifest. As chaves de tipo são comparadas com tolerância de versão, pelo que core/api-server, core/api-server:1.0.0 e core/api-server:2.0.0, escritas como chaves de mapeamento separadas, respondem todas pelo mesmo tipo base — e uma pesquisa que alcance duas delas tem duas Recipes entre as quais escolher e nenhuma regra para preferir uma.
A compilação é interrompida em vez de resolver a chave que por acaso leu primeiro. Escolher uma faria a saída gerada depender da ordem pela qual o mapeamento foi percorrido, que é exatamente o que uma saída idêntica byte a byte exclui.
Mensagem emitida:
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 (o Manifest mapeia várias chaves de versões distintas para o mesmo tipo base; a pesquisa de tipo para Recipe é ambígua: o tipo corresponde a chaves de versões distintas — fixe a versão do tipo escrito ou remova as chaves de mapeamento duplicadas)
Como corrigir: duas direções, e a mensagem indica ambas. Remover as chaves de mapeamento duplicadas, mantendo a que deve responder pelo tipo — é o correto quando as chaves extra são restos de um aumento de versão. Ou fixar a versão do lado da autoria, para que o tipo que o componente declara indique exatamente a chave pretendida, o que é o correto quando as várias chaves são deliberadas e componentes diferentes querem realmente Recipes diferentes.
Two catalog entities in one directory share an identity (Duas entidades do catálogo num mesmo diretório partilham uma identidade)
Duas entidades do mesmo tipo, carregadas a partir do mesmo diretório de catálogo, têm a mesma identidade. Uma identidade é o que uma referência indica, pelo que dois ficheiros que reivindicam uma mesma identidade deixam cada referência a ela com duas respostas.
Dentro de um diretório, isto interrompe a compilação; entre diretórios, não. A mesma identidade presente em dois diretórios de catálogo diferentes é resolvida como um sombreamento em que o primeiro ganha — ganha o diretório listado primeiro —, que é o que permite a um diretório local substituir deliberadamente uma entidade publicada. Só uma colisão dentro de um mesmo diretório é um erro de autoria que nenhuma leitura torna intencional.
A regra é a mesma para todos os tipos de entidade indexados: Component, Feature, Recipe, FeatureRecipe, Plugin, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary e Aggregate. A interrupção é posicionada no segundo ficheiro e indica o tipo e a identidade que colidiram.
Mensagem emitida:
duplicate entity identity within a single catalog directory (Component identity "<identity>") (identidade de entidade duplicada dentro de um único diretório de catálogo (identidade de Component))
com a palavra própria do tipo no lugar de Component — recipe identity, feature recipe identity, Plugin identity, SchemaLibrary identity e assim por diante.
Como corrigir: mudar o nome de uma das duas entidades, ou movê-la para um diretório próprio. Para uma Recipe ou uma FeatureRecipe, a identidade inclui o âmbito do fornecedor e a versão, pelo que dois ficheiros que diferem apenas na versão não colidem — uma colisão real nesse caso significa que a mesma versão foi publicada duas vezes. A causa habitual é copiar o ficheiro de uma entidade para começar uma nova e esquecer de alterar metadata.name.
A file the operation reads leads through a link out of the directory it must stay inside (Um ficheiro que a operação lê conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar)
Dois locais são lidos como um todo em vez de um ficheiro de cada vez: um diretório de catálogo, a partir de qualquer documento abaixo do qual uma pesquisa por nome pode obter a resposta, e o diretório que contém uma Release, em relação a cujos Aggregates e Manifests é resolvida uma Release que os indica por identidade. Uma ligação simbólica entre esses ficheiros pode conduzir a qualquer lado da máquina, pelo que cada um desses diretórios tem um diretório dentro do qual as suas leituras têm de ficar, e uma ligação que sai dele não é lida. A fronteira do espaço de trabalho enuncia a regra que aqui se aplica, e os outros caminhos que ela abrange.
Que diretório é esse depende de onde se situa o diretório que está a ser lido:
O espaço de trabalho, para um diretório de catálogo ou o diretório de uma Release dentro dele. Isto aplica-se ao diretório convencional catalog do espaço de trabalho sempre que ninguém o indicou — quando é lido apenas por estar lá: nesse caso pertence ao próprio espaço de trabalho, pelo que um catalog que seja ele próprio uma ligação que conduz para fora do espaço de trabalho não é lido.
Um diretório indicado pelo utilizador que fica fora do espaço de trabalho, para o que fica abaixo dele: um diretório de catálogo passado com --catalog, ou que a configuração do espaço de trabalho lista em catalog_dirs — para o espaço de trabalho ou para uma única Release —, e o diretório de uma Release indicada pelo utilizador, ou pela configuração, que fica fora do espaço de trabalho. O próprio diretório é usado tal como foi indicado — um que seja uma ligação é lido onde aponta — e o que é lido abaixo dele fica dentro dele. Isto inclui o diretório convencional catalog a partir do momento em que é indicado: listado em catalog_dirs, ou passado com --catalog, um catalog que seja uma ligação que conduz para fora do espaço de trabalho é lido onde aponta, como qualquer outro diretório indicado. Indicar em vez disso o local para onde aponta, em qualquer grafia, ou um diretório acima desse local, também o indica: o diretório indicado já lê o que lá está, pelo que é lido uma única vez, através desse diretório. Indicar um diretório na configuração é a forma de um espaço de trabalho ler entidades guardadas fora dele.
O que é avaliado é cada entrada da qual a leitura retiraria algo: uma ligação para um ficheiro com nome de documento YAML, e uma ligação para um diretório, que pode conter documentos próprios. Uma ligação que conduz a algum lado dentro do diretório no qual a leitura tem de ficar é lida onde o percurso a encontra. Uma ligação para um ficheiro do qual nenhuma leitura do catálogo retira nada — um ficheiro de notas, um arquivo de chart — não é avaliada aqui, e uma ligação que não conduz a lado nenhum não tem nada por trás para ler.
Uma pesquisa de que depende uma compilação para numa ligação destas em vez de passar por cima dela. A entidade por trás da ligação pode ser a que uma referência indica, e passar por cima dela em silêncio deixaria outra entidade com o mesmo nome, de um diretório de catálogo posterior, ser resolvida em seu lugar. Assim, aggrega build, aggrega pull, aggrega validate, aggrega inspect onde quer que leia o catálogo, um lint de uma única Release, e os pedidos do editor e de um assistente que compilam, pré-visualizam, representam em grafo, validam ou descrevem uma Release param todos antes de qualquer coisa ser resolvida, indicando a ligação. Um lint de todo o catálogo para da mesma forma: o seu veredicto responde por cada documento que os diretórios de catálogo contêm, pelo que não comunica um catálogo limpo enquanto um deles não pôde ser lido. O diretório da Release está sujeito à mesma regra sempre que uma Release indique o seu Aggregate ou o seu Manifest por identidade, ou que um Manifest indique dessa forma o Manifest que estende, e a análise para numa ligação entre os documentos junto à Release mesmo quando a ligação não é a que uma referência indica, pela mesma razão pela qual um duplicado a para aí: o diretório não pode responder por um nome enquanto um dos seus documentos não puder ser lido. A Release sobre a qual a operação foi invocada — ou um Manifest inspecionado isoladamente — não é um desses documentos: foi lida onde foi indicada, pelo que uma Release que seja ela própria uma ligação que conduz para fora é lida onde aponta, e o que ela indica é procurado junto à ligação, no diretório em que foi indicada (Uma Release ou um Manifest indicado através de uma ligação).
Uma listagem, pelo contrário, passa por cima de uma ligação destas e não lista nada do que está por trás dela. O índice de entidades do editor, as suas conclusões automáticas e os candidatos que propõe não listam uma entidade representada por uma ligação que conduz para fora, e o índice de entidades indica uma ligação destas dentro do espaço de trabalho entre as ligações que não leu.
Os ficheiros de configuração do espaço de trabalho estão sujeitos ao espaço de trabalho da mesma forma. Todos os .aggrega-config.yaml desde a raiz do espaço de trabalho até ao diretório em que um comando corre, e o .aggrega-config-append-ci.yaml que um pipeline mantém ao lado de qualquer um deles, são conteúdo próprio do espaço de trabalho. Um que seja uma ligação que conduz para fora do espaço de trabalho — ou que seja alcançado através de uma ligação de diretório que conduz para fora — não é lido, e como todos os comandos, o servidor de linguagem do editor e as ferramentas de um assistente leem a configuração antes de tudo o resto, cada um para aí, indicando a ligação, em vez de correr com uma configuração feita a partir do que restou. O servidor de linguagem, e o servidor de um assistente que fala através dos seus próprios fluxos, arrancam mesmo assim sobre um espaço de trabalho destes: as listagens das suas Releases e das suas entidades respondem, lidas sem nada configurado, e indicam o ficheiro entre as ligações que não leram, enquanto todos os outros pedidos que a configuração decide são recusados com esta condição, indicando a ligação. A solução que esta mensagem indica é a da própria configuração: o ficheiro de configuração global é a única configuração lida onde quer que esteja guardada, indicada com --config ou AGGREGA_CONFIG.
O ficheiro de bloqueio de uma Release está sujeito à mesma regra, tanto onde é lido como onde é escrito. O ficheiro de bloqueio junto a uma Release é lido para obter as fixações em relação às quais resolvem uma compilação, um pull, uma validação, um lint, uma inspeção, aggrega cache prune e os pedidos do editor e de um assistente, e está sujeito ao diretório a que a sua escrita está sujeita: o espaço de trabalho, ou o diretório próprio da Release no caso de uma Release indicada fora dele. Um que seja uma ligação que conduz para fora não é lido, e cada uma dessas operações para indicando a ligação em vez de resolver em relação a fixações guardadas noutro lado da máquina, ou sem eles. A solução que esta mensagem indica é a do próprio ficheiro de bloqueio: tem um único lugar, junto à Release, onde um pull o escreve.
Um ficheiro lido junto a uma entidade está sujeito à mesma regra. Duas operações leem um ficheiro que se encontra junto ao próprio documento de uma entidade, em vez de um que uma referência indica. Fixar uma entidade, ou publicá-la, lê todos os outros documentos YAML do diretório da entidade para saber se outra entidade o partilha. Carregar uma entidade Plugin escrita num diretório de catálogo lê o .wasm compilado colocado junto a ela. Cada um está sujeito ao diretório sob o qual o próprio documento da entidade foi lido — o espaço de trabalho, um diretório de catálogo indicado fora dele ou, para uma entidade que se fixa ou publica indicando o seu documento fora do espaço de trabalho, o diretório próprio desse documento — e um que seja uma ligação que conduz para fora dele não é lido. aggrega pin, aggrega push com ou sem --dry-run, um pull que fixa, e a fixação e a publicação pelo editor e por um assistente param indicando a ligação, porque um documento deixado por ler poderia ser a entidade que está a atrapalhar. Uma compilação ou um pull que carregue o plugin também para indicando a ligação, em vez de executar bytes guardados noutro lado da máquina ou de procurar o plugin noutro lado. A solução que esta mensagem indica é a de um ficheiro junto a uma entidade: guardar aí o próprio ficheiro.
A cache de artefactos do espaço de trabalho está sujeita à mesma regra, tanto onde é lida como onde é escrita. Tudo o que é lido da cache em artifact_cache_dir — uma entidade, um plugin ou uma biblioteca em cache e o manifesto ao lado, um arquivo de código-fonte e os seus metadados, uma entrada externa fixada, um bundle de assinatura, o índice de pesquisa local de um registo — e cada entrada do espaço de trabalho que aggrega cache status, aggrega cache prune e aggrega cache clear listam, está sujeito ao diretório a que está sujeita uma escrita na cache: o próprio diretório da cache, tanto o .aggrega/cache predefinido como um que a configuração indique subindo para fora da raiz do espaço de trabalho. Qualquer coisa nela que seja uma ligação que conduz para fora do diretório da cache — para outro lado dentro do espaço de trabalho tanto como para qualquer outro lado — não é lida, nem qualquer coisa por trás de um diretório de cache escrito dentro da raiz do espaço de trabalho que seja ele próprio uma ligação que conduz para fora do espaço de trabalho: uma compilação, um pull, uma validação, uma pesquisa, os três comandos da cache e os pedidos do editor e de um assistente que leem a cache param indicando a ligação — incluindo o conteúdo que a cache guarda sob um digest registado, uma vez que um digest diz o que os bytes são, e não de onde podem ser lidos. Um diretório de cache escrito dentro da raiz do espaço de trabalho que seja uma ligação para outro lado dentro do espaço de trabalho é lido onde conduz. O aviso de descontinuação que aggrega inspect imprime, que não decide nada, fica de fora. Um prune ou um clear trata um dos diretórios próprios da cache que seja uma ligação que conduz para fora do diretório da cache, ou um diretório de cache que seja ele próprio uma ligação que conduz para fora do espaço de trabalho, como a remoção que seria, em «A path the operation writes leads through a link out of the directory it must stay inside (Um caminho que a operação escreve conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar)», antes de listar qualquer coisa. A solução que esta mensagem indica é a da própria cache: removida a ligação, um pull volta a preencher a cache, e uma cache guardada noutro lado é indicada com artifact_cache_dir, relativa à raiz do espaço de trabalho, em vez de ser alcançada através de uma ligação.
Um repositório que uma fonte obtém está sujeito ao seu próprio checkout. Quando um pull — aggrega pull, ou uma compilação ou um pedido do editor ou de um assistente que resolve as dependências de uma Release — obtém uma fonte git-repository, faz o checkout do repositório e arquiva o diretório que a fonte indica, e o checkout é um diretório à parte: todas as ligações que o repositório contém, incluindo o próprio module_subdir, estão sujeitas a ele. Uma ligação para um ficheiro ou um diretório dentro do repositório é arquivada como aquilo para que aponta, com o nome da ligação. Uma ligação que conduz para fora do repositório — que poderia apontar para qualquer ficheiro da máquina que executa o pull — não é lida: o pull para indicando a ligação e para onde conduz, e nada é guardado em cache. O checkout é um diretório temporário removido assim que o pull para, pelo que a mensagem indica a ligação pela sua posição no repositório — chart/secret.txt, como na primeira linha da saída da linha de comandos e na frase — e o diretório dentro do qual tem de ficar como o repositório e a revisão que a fonte indica: which must stay inside the repository <url> at <ref> (commit <commit>), ou at commit <commit> quando a fonte não indica nenhum ref ou indica o próprio commit. O local para onde a ligação conduz é indicado como o local que é na máquina do utilizador. A solução que esta mensagem indica é a do próprio repositório: a ligação foi registada aí num commit, pelo que é aí que se altera — fazendo-a apontar para dentro do repositório, ou substituindo-a pelo próprio ficheiro — e a fonte indica então uma revisão que contenha a alteração. Uma ligação de diretório que conduz de volta a um diretório que o arquivamento já está a ler através dela também para o pull, porque a árvore que representa não tem fim; essa recusa é um erro simples e não esta condição.
As sobreposições que uma geração de catálogo lê estão sujeitas à mesma regra.aggrega plugin gen-catalog --from-embedded lê cada sobreposição abaixo do diretório de sobreposições que recebe — escrito com --overlay, escolhido no editor ou indicado por um assistente — e sujeita cada uma ao diretório sob o qual esse diretório de sobreposições é lido: o espaço de trabalho, para um diretório de sobreposições dentro dele, e o próprio diretório de sobreposições para um indicado fora do espaço de trabalho. O diretório de sobreposições é usado tal como foi indicado — um que seja uma ligação é lido onde aponta. Uma sobreposição abaixo dele que seja uma ligação que conduz para fora do diretório a que está sujeita não é lida, nem uma ligação de diretório que conduz para fora dele, que pode conter sobreposições próprias: a geração para indicando a ligação, sem nada escrito, em vez de gerar sem a sobreposição. Uma sobreposição que seja uma ligação que conduz para outro lado dentro do diretório a que está sujeita é lida onde aponta; uma ligação de diretório que conduz para dentro dele não é percorrida. A solução que esta mensagem indica é a de uma sobreposição: guardar a própria sobreposição abaixo do diretório de sobreposições, ou indicar como diretório de sobreposições um diretório que contenha todas as sobreposições.
Um diretório importado fica restrito a si próprio.aggrega import com um diretório, a ferramenta de importação do assistente e o método aggrega/import da sessão entregam ao importador os ficheiros do diretório que os seus padrões de ficheiro selecionam, cada um no seu lugar no diretório, pelo que o diretório é aquele dentro do qual essas leituras permanecem, onde quer que se encontre — dentro do espaço de trabalho tanto como fora dele. O que é avaliado é cada entrada da qual a importação tiraria algo: uma ligação a um ficheiro que um dos padrões relevantes seleciona — os padrões do importador que serve o formato indicado ou, onde o formato é reconhecido, os de cada importador entre os quais a importação escolhe, incluindo os importadores core do compilador — e uma ligação a um diretório, no qual nunca se entra. Uma ligação que sai do diretório, para outro ponto do espaço de trabalho ou para qualquer outro lugar, não é lida: a importação para, indicando a ligação, antes de ser aberto qualquer ficheiro do diretório, sem nada escrito. Uma ligação selecionada a um ficheiro noutro ponto dentro do diretório é lida onde aponta, com o nome da própria ligação, e uma ligação a um ficheiro que nenhum padrão seleciona não é avaliada nem lida. O próprio diretório é utilizado tal como foi indicado — um diretório que é uma ligação é lido onde aponta. Alcançada através de um listener, a ferramenta do assistente indica a ligação pelo seu lugar no espaço de trabalho e nada diz sobre para onde leva. A solução que esta mensagem indica é a própria de um diretório importado: manter o próprio ficheiro no diretório em vez de uma ligação para ele, ou importar o diretório para o qual a ligação leva.
Mensagem emitida. Começa com a frase própria da condição, depois o caminho que a leitura alcançou, o diretório dentro do qual deve permanecer, a ligação que encontra pelo caminho e o lugar para onde essa ligação leva, e depois a solução:
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 (um ficheiro que esta operação lê sai, através de uma ligação, do diretório dentro do qual deve permanecer (ao ler um ficheiro que deve permanecer dentro do espaço de trabalho, a ligação leva a outro lugar). nada foi lido através dessa ligação. Remova a ligação, ou faça-a levar a um lugar dentro do espaço de trabalho. Para ler o que é mantido fora, liste o diretório que o contém como diretório de catálogo na configuração do espaço de trabalho, em vez de o alcançar através de uma ligação sob um deles: um diretório listado é lido onde leva, mesmo quando é ele próprio uma ligação)
O diagnóstico não tem categoria: o que está errado é a disposição no disco, e não qualquer documento escrito pelo utilizador.
Como corrigir: substitua a ligação por uma cópia daquilo para onde leva, ou remova-a; ou, quando a entidade se destina a permanecer fora do espaço de trabalho, liste o diretório que a contém em catalog_dirs na configuração do espaço de trabalho, ou passe-o com --catalog, para que o diretório seja lido como um diretório de catálogo próprio. Liste o diretório para o qual a ligação leva, e não aquele onde ela se encontra: uma ligação encontrada sob um diretório é avaliada da mesma forma, seja qual for a maneira como esse diretório passou a ser lido, pelo que listá-lo não altera nada. Quando a ligação é o próprio diretório catalog convencional do espaço de trabalho, basta listar catalog — ou o diretório para o qual aponta — em catalog_dirs, ou passar qualquer um dos dois com --catalog, já que um diretório indicado é lido onde aponta. Quando a ligação é o ficheiro de bloqueio de uma Release, remova-a e faça novamente o pull da Release, o que escreve um ficheiro de bloqueio novo ao lado dela. Um Manifest não tem nível de catálogo, pelo que um Manifest que a Release lê é mantido ao lado da própria Release. Quando a ligação é um ficheiro de configuração, substitua-a por uma cópia mantida no espaço de trabalho; uma configuração que se pretende partilhar entre espaços de trabalho é lida indicando-a como o ficheiro de configuração global, com --config ou AGGREGA_CONFIG, abaixo dos ficheiros próprios de cada espaço de trabalho. Quando a ligação se encontra ao lado de uma entidade que está a ser fixada ou publicada, substitua-a pelo próprio ficheiro, ou mova um documento que é uma entidade para um diretório próprio; quando é o .wasm ao lado de uma entidade Plugin, coloque aí o próprio .wasm compilado. Quando a ligação é o diretório da cache de artefactos ou algo dentro dele, remova-a — um pull volta a preencher a cache — ou, para manter a cache noutro lugar, defina artifact_cache_dir para esse diretório, escrito em relação à raiz do espaço de trabalho (../shared-cache). Quando a ligação está consolidada num repositório que uma fonte git-repository obtém, altere-a nesse repositório — faça-a apontar para dentro do repositório, ou consolide o próprio ficheiro — e indique a revisão que contém a alteração. Quando a ligação é uma sobreposição sob o diretório de sobreposições de uma geração de catálogo, substitua-a pela própria sobreposição, ou indique como diretório de sobreposições um diretório que contenha todas as sobreposições. Quando a ligação se encontra num diretório que se importa, mantenha o próprio ficheiro no diretório em vez de uma ligação para ele, ou importe o diretório para o qual a ligação leva.
A reference to another file leads out of the directory it must stay inside (Uma referência a outro ficheiro sai do diretório dentro do qual deve permanecer)
Uma Release e um Manifest podem indicar outro ficheiro através de um caminho: os aggregate: e manifest: de uma Release escritos como ./… ou ../…, o seu extends:, o extends: de um Manifest escrito como caminho, e os parameters: { $import: … } de uma Release. Um documento no espaço de trabalho só alcança dessa forma ficheiros dentro do espaço de trabalho. Uma Release que se encontra fora do espaço de trabalho — uma indicada na linha de comandos, ou uma que a configuração do espaço de trabalho indica — e um Manifest indicado sozinho na linha de comandos fora do espaço de trabalho só alcançam ficheiros dentro do seu próprio diretório: esse diretório é uma raiz própria, tal como o é um diretório indicado fora do espaço de trabalho, e cada Release a que a sua cadeia extends: leva fica restrita ao mesmo diretório. Um caminho que, tal como está escrito, sobe para fora desse diretório, e um caminho que permanece dentro tal como está escrito mas encontra pelo caminho uma ligação simbólica que leva para fora, são ambos recusados, e nada é lido do ficheiro que indicam. Um caminho que leva a um ficheiro que ainda não existe sob o diretório não é recusado aqui; é comunicado como um ficheiro que não foi possível ler. A fronteira do espaço de trabalho explica por que razão uma referência fica restrita, tal como o caminho indicado.
O ponto a partir do qual um caminho é resolvido segue a mesma regra que a referência da linguagem ensina para cada chave: os aggregate: e manifest: de uma Release, e o extends: de um Manifest, ao lado da Release que um comando ou um pedido indica — ou, para um Manifest indicado sozinho, ao lado desse Manifest; o extends: de uma Release e um $import: dos parâmetros, ao lado da Release que o escreve, pelo que cada elo de uma cadeia extends: indica o seu pai ao lado de si próprio. O diagnóstico indica o diretório a partir do qual foi resolvido.
Um nome em vez de um caminho não é avaliado aqui — aggregate: payments, extends: base-manifest. É procurado entre os documentos ao lado da Release e, para um Aggregate, nos diretórios de catálogo, que ficam restritos pela regra em «A file the operation reads leads through a link out of the directory it must stay inside (Um ficheiro que a operação lê conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar)» acima.
Cada superfície que resolve o que uma Release indica para aí, antes de o ficheiro ser lido: aggrega pull, aggrega build, aggrega validate, aggrega inspect de uma Release ou de um Manifest, um lint de uma única Release, e os pedidos do editor e de um assistente que compilam, pré-visualizam, representam como grafo, validam ou descrevem uma Release. No editor, o diagnóstico é colocado na chave da Release que levou ao ficheiro.
Mensagem emitida. Começa com a frase própria da condição, depois a referência tal como está escrita, o documento em que está escrita para um extends: e um $import: dos parâmetros, o diretório a partir do qual é resolvida, o lugar para onde leva, o diretório dentro do qual deve permanecer, e a ligação, quando uma a leva para fora; depois a solução. Para um documento no espaço de trabalho:
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 (uma referência que um documento faz a outro ficheiro sai do diretório dentro do qual deve permanecer: a referência, resolvida a partir do espaço de trabalho, leva para fora do espaço de trabalho. nada foi lido desse ficheiro. Um documento no espaço de trabalho só alcança ficheiros dentro do espaço de trabalho: mova o ficheiro para lá — ou, quando uma ligação leva a referência para fora, faça a ligação levar para lá — ou abra o espaço de trabalho num diretório que contenha ambos os documentos. Um Aggregate mantido fora desse diretório é alcançado pelo nome em vez de por um caminho, a partir de um diretório de catálogo que a configuração do espaço de trabalho lista)
e para uma Release ou um Manifest indicados fora do espaço de trabalho, cujo próprio diretório é aquele dentro do qual devem 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 (uma referência que um documento faz a outro ficheiro sai do diretório dentro do qual deve permanecer: a referência, resolvida a partir do diretório, leva para fora do diretório de um documento indicado fora do espaço de trabalho. nada foi lido desse ficheiro. Uma Release ou um Manifest indicados fora do espaço de trabalho — na linha de comandos, ou pela configuração do espaço de trabalho — só alcançam ficheiros dentro do seu próprio diretório: mova o ficheiro para lá — ou, quando uma ligação leva a referência para fora, faça a ligação levar para lá — ou indique o documento a partir de um espaço de trabalho que contenha ambos os documentos. Um Aggregate mantido fora desse diretório é alcançado pelo nome em vez de por um caminho, a partir de um diretório de catálogo que a configuração do espaço de trabalho lista)
com written in <document> após a referência para um extends: ou um $import: dos parâmetros, e the link <link> leads to <place> no fim, quando uma ligação leva o caminho para fora. Uma referência aggregate: ou manifest: não indica nenhum documento: uma Release que estende outra pode tê-la herdado de uma Release mais acima na cadeia, e é resolvida ao lado da Release que o comando indica em qualquer caso.
A categoria do diagnóstico é [OPS_ERROR]: a referência está escrita numa Release ou num Manifest.
Como corrigir: para um Aggregate mantido fora do espaço de trabalho, escreva o seu metadata.name em vez de um caminho, e liste o diretório que o contém em catalog_dirs na configuração do espaço de trabalho, ou passe-o com --catalog — um diretório de catálogo é a forma como um espaço de trabalho alcança entidades mantidas fora dele. Um Manifest, uma Release que um extends: indica e um ficheiro de parâmetros são lidos ao lado da Release e nunca procurados pelo nome, pelo que devem ser mantidos dentro do espaço de trabalho, ou o espaço de trabalho deve ser aberto num diretório que contenha tanto a Release como o ficheiro. Para uma Release ou um Manifest indicado a partir de fora do espaço de trabalho, mantenha o que indica no seu próprio diretório, ou compile-o no espaço de trabalho que contém tanto o documento como o que ele indica. Quando uma ligação leva o caminho para fora, substitua a ligação por uma cópia daquilo para onde leva, ou faça-a levar para dentro do diretório.
No catalog version satisfies a version constraint (Nenhuma versão do catálogo satisfaz uma restrição de versão)
Uma referência indica uma entidade que o catálogo contém e fixa uma versão que o catálogo não contém: uma versão exata ausente, ou um intervalo caret ao qual nada do que está disponível corresponde. É distinta de uma simples ausência, em que o próprio nome é desconhecido — aqui a entidade existe e só a versão não pode ser satisfeita, e é por isso que a mensagem o diz, em vez de comunicar a entidade como em falta e mandar procurar um erro de escrita no nome.
Todos os tipos de entidade chegam aqui através de uma única seleção, pelo que uma fixação impossível de satisfazer se comporta da mesma forma onde quer que esteja escrita: um erro de escrita de versão no mapeamento de uma Recipe de um Manifest é recusado exatamente como o mesmo erro num tipo de componente.
A condição é recuperável, o que permite ao editor mostrá-la como diagnóstico enquanto se continua a escrever, em vez de abandonar o documento. Na linha de comandos, é reunida numa interrupção.
Mensagem emitida, para uma referência que as dependências de uma Release alcançam — um tipo de componente, um valor de mapeamento de um Manifest — indicando onde foi recolhida:
no catalog version satisfies the referenced version constraint: entity "<reference>" (referenced from <referring paths>) (nenhuma versão do catálogo satisfaz a restrição de versão referenciada)
Mensagem emitida, para uma fixação num ponteiro extends::
no catalog version satisfies the referenced version constraint (Component <name>, at .extends, no catalog version satisfies extends parent "<reference>") (nenhuma versão do catálogo satisfaz a restrição de versão referenciada: nenhuma versão do catálogo satisfaz o pai de extends)
com Feature em vez de Component quando é a cadeia de uma Feature que contém a fixação.
Como corrigir: altere a fixação para uma versão que o catálogo contém, ou adicione essa versão ao catálogo. aggrega inspect lista as versões em que uma entidade está disponível. Um intervalo caret ao qual nada corresponde significa normalmente que as versões disponíveis estão todas abaixo do mínimo que indica — alargue o intervalo, ou publique a versão de que a referência está à espera.
Uma fixação que não tem nenhuma das formas que uma fixação assume é uma condição diferente, descrita abaixo em «A version pin is none of the forms a pin takes (Uma fixação de versão não tem nenhuma das formas que uma fixação assume)».
A version pin is none of the forms a pin takes (Uma fixação de versão não tem nenhuma das formas que uma fixação assume)
Uma referência nomeia outra entidade e pode fixar a versão que pretende após dois pontos, numa de duas formas: uma fixação exata, que é uma versão semântica como 1.0.0 — a forma que o metadata.version de qualquer entidade assume — ou uma fixação caret, ^ seguido de uma versão como ^1.0.0, que seleciona a versão mais alta compatível com ela. Uma fixação que não é nenhuma das duas — um caret cujo texto não se lê como um intervalo de versões, como ^garbage, ou uma fixação exata que não é uma versão semântica, como 1.x, 1.0 ou v1.0.0 — não nomeia versão alguma, pelo que nenhum catálogo poderia conter aquilo que pede.
Uma fixação deste tipo é comunicada como malformada em vez de como uma entidade ou uma versão que o catálogo não contém, para que o diagnóstico remeta para o texto escrito em vez de levar a procurar algo que não existe. É a mesma condição onde quer que a fixação esteja escrita: o type de um componente ou de uma funcionalidade, o extends: de um Component ou de uma Feature, uma chave ou um valor de mapeamento de um Manifest, o spec.aggregate de uma Release, o implements: de uma Recipe ou de uma FeatureRecipe, a versão que o capability: de uma Recipe fixa quando o plugin que a serve é selecionado, e o plugin: de um passo de pipeline.
É comunicada onde é comunicada uma referência que não pôde ser resolvida, pelo que uma fixação malformada nunca altera quais as referências que se resolvem — altera o que a falha diz. Uma fixação bem formada, mas que nenhuma versão disponível satisfaz, mantém a condição que essa superfície comunica para ela: «No catalog version satisfies a version constraint (Nenhuma versão do catálogo satisfaz uma restrição de versão)» acima, ou a condição de não encontrado da superfície em que está escrita.
Apenas o texto após os últimos dois pontos é uma fixação, e apenas quando não contém /. Uma referência a um host de registo com uma porta, como localhost:5000/core/api-server, não contém, portanto, nenhuma fixação — o texto após os dois pontos da porta continua a referência — e nunca é comunicada como uma fixação malformada.
Mensagem emitida, para uma fixação caret num 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 (a referência contém uma fixação de versão malformada (referência, fixação, o texto após ^ não é um intervalo de versões, referenciada a partir da localização em que está escrita). escrever a referência como nome, como nome:versão com uma versão semântica como 1.0.0, ou como nome:^versão para a versão mais alta compatível com ela)
Uma fixação exata apresenta an exact pin must be a semantic version em vez da cláusula do caret. O valor que se segue indica onde a referência foi escrita, nas palavras da superfície que a comunica — referenced from e a localização em que está escrita, in the Release's spec.aggregate ou in the recipe's spec.implements. Quando um mapeamento de um Manifest é avaliado face ao implements: da sua Recipe, a entrada do mapeamento e o lado dela que contém a fixação — in the mapping key ou in the recipe's spec.implements — surgem, em vez disso, antes da referência, e o extends: de um Component ou de uma Feature nomeia a entidade que estende e o campo antes dela.
Como corrigir: reescrever a fixação numa das duas formas, ou removê-la para selecionar a versão mais alta disponível. Um padrão genérico como 1.x escreve-se como uma fixação caret, ^1.0.0; uma versão com um v inicial ou com menos de três números escreve-se por extenso, 1.0.0.
Every version a reference could select has been withdrawn (Todas as versões que uma referência poderia selecionar foram retiradas)
Uma referência resolve-se num repositório que o registo contém, e todas as versões entre as quais a descoberta de versões poderia ter escolhido foram marcadas como retiradas. Não resta nada elegível para selecionar.
Isto não é comunicado, deliberadamente, como uma entidade em falta. O repositório existe e ainda contém essas versões; chamá-lo ausente nomearia o problema errado, levaria a procurar um erro de digitação e pareceria um recurso alternativo silencioso em vez da recusa que é. A mensagem nomeia cada versão retirada com o motivo registado para ela, pelo que aquilo que é comunicado é aquilo que quem a publicou registou.
Nomear uma versão retirada explicitamente não é esta interrupção. Uma versão exata contorna completamente a descoberta de versões, pelo que fixar uma é a forma de continuar deliberadamente a utilizá-la; a compilação comunica a retirada e prossegue.
Mensagem emitida:
every published version this reference could select has been withdrawn: <reference>: withdrawn: <version> (<recorded reason>), <version> (<recorded reason>) (todas as versões publicadas que esta referência poderia selecionar foram retiradas: retiradas, cada uma com o motivo registado)
Como corrigir: ler os motivos registados, que costumam indicar para onde migrar. Migrar para aquilo que substitui a entidade retirada — é esse o resultado que uma retirada pede. Quando for preciso manter a antiga por agora, fixar uma versão exata na referência: nomear a versão é o que indica que é aceite, e a compilação passa então a comunicar a retirada de cada vez em vez de recusar.
A plugins.providers binding names a plugin that does not serve the capability (Uma associação nomeia um plugin que não serve a capacidade)
O bloco plugins.providers do espaço de trabalho seleciona uma identidade de plugin para uma capacidade, e nenhum Plugin de renderização de fornecedores que sirva essa capacidade tem essa identidade. A associação é uma escolha explícita que o catálogo não pode respeitar, pelo que provoca uma interrupção em vez de recorrer silenciosamente a outro plugin — um recurso alternativo renderizaria o resultado através de um plugin que se tinha indicado para não usar, sem dizer nada.
Uma associação seleciona pela identidade de coordenada do plugin — o tipo de plugin e o nome do plugin, que é também aquilo que o ficheiro de bloqueio fixa — e pode conter uma versão a seguir.
É avaliada quer uma Recipe peça a capacidade, quer não. Caso contrário, uma associação só é lida quando o capability: de uma Recipe a nomeia, pelo que uma associação cuja capacidade está mal escrita não seria consultada por nada nem comunicada por nada. Cada compilação e cada aggrega validate --release verificam, portanto, cada associação que nomeia um plugin: um pull resolve uma associação destas quer uma Recipe a use, quer não, pelo que a compilação contém o plugin e sabe o que este serve, e uma capacidade que esse plugin não serve está certamente errada. A verificação lê as associações na configuração do espaço de trabalho, não o ficheiro de bloqueio, e não altera nada quanto ao plugin que renderiza uma Recipe — isso continua a caber ao ficheiro de bloqueio. Uma associação que nomeia um plugin que a compilação não contém — um plugin de registo que nenhum pull obteve ainda — só é avaliada depois de um pull o ter obtido. Uma associação que não nomeia nenhum plugin é avaliada de outra forma, como um aviso: ver «A provider binding names a capability no plugin the build reads serves (Uma associação de fornecedor nomeia uma capacidade que nenhum plugin lido pela compilação serve)» em «Condições que não interrompem uma compilação» mais abaixo.
Mensagem emitida, que acrescenta aquilo que o plugin nomeado de facto serve, e uma grafia a uma edição de distância quando a capacidade da associação o 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>" (a entrada plugins.providers nomeia um plugin ao qual não corresponde nenhum plugin de renderização de fornecedores que sirva a capacidade: a capacidade está associada ao plugin, mas nenhum plugin de renderização de fornecedores que a sirva corresponde a essa identidade; o plugin serve outra capacidade, e a capacidade está a uma edição de distância dela)
Quando o plugin que a associação nomeia não está no catálogo que a compilação lê, a mensagem termina após «matches that identity (corresponde a essa identidade)», porque não há nada a dizer sobre aquilo que serve.
Como corrigir: verificar primeiro a grafia da associação face à coordenada do próprio plugin — uma associação que nomeia a capacidade onde deveria nomear o plugin é o deslize comum. Quando a mensagem nomeia uma capacidade a uma edição de distância da que foi escrita, o erro de digitação está no capability: da associação. Depois, confirmar que o plugin está no catálogo que a compilação lê e que lista esta capacidade em spec.provider.capabilities; um plugin que em tempos serviu a capacidade e já não a declara produz exatamente esta mensagem. Remover a associação é a correção certa quando apenas um plugin serve a capacidade, uma vez que a associação deixa então de ter algo a desambiguar.
No provider plugin version satisfies a Recipe’s provider pin (Nenhuma versão de plugin fornecedor satisfaz a fixação de fornecedor de uma Recipe)
Uma Recipe associa um fornecedor com versão fixada — helm:1.0.0 ou helm:^1.0.0 — e nenhuma versão de Plugin de renderização de fornecedores satisfaz a fixação. A fixação é um pedido explícito, pelo que a compilação é interrompida em vez de a ignorar e renderizar através de qualquer versão que sirva o fornecedor nesse momento; sobrepor uma fixação silenciosamente produziria um resultado que a própria declaração do autor diz que não deveria existir.
Há duas situações que conduzem a ela, e a mensagem distingue-as: nada serve a capacidade, ou algo a serve e nenhuma das suas versões satisfaz a restrição.
Isto é distinto de uma versão de entidade insatisfazível acima. Essa diz respeito a uma entidade do catálogo nomeada numa versão que o catálogo não contém; esta diz respeito à seleção do plugin que renderiza uma capacidade.
Mensagens emitidas:
no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no provider-rendering plugin serves it (nenhuma versão de plugin de renderização de fornecedores satisfaz a fixação de versão de fornecedor da Recipe: a capacidade fixa uma versão, mas nenhum plugin de renderização de fornecedores a serve) no provider-rendering plugin version satisfies the recipe’s provider version pin: capability "<capability>" pins "<version>" but no serving plugin version satisfies it (nenhuma versão de plugin de renderização de fornecedores satisfaz a fixação de versão de fornecedor da Recipe: a capacidade fixa uma versão, mas nenhuma versão de plugin que a sirva a satisfaz)
Como corrigir: alargar ou corrigir a fixação no campo capability: da Recipe, ou adicionar ao catálogo a versão do plugin que ela pede. Uma fixação caret corresponde a versões iguais ou superiores ao mínimo dentro da mesma versão principal, pelo que uma fixação ^2.0.0 não é satisfeita por um plugin 1.x, por mais recente que seja. Quando a mensagem diz que nada serve a capacidade, o problema não é a fixação: o plugin está totalmente em falta, e remover a fixação não vai ajudar.
No plugin advertises a requested parse or import format (Nenhum plugin anuncia um formato de análise ou de importação pedido)
Foi pedido um formato e nenhum plugin o anuncia. Os dois sockets que encaminham por formato têm cada um a sua própria condição, e diferem apenas no trabalho que foi pedido: um plugin analisador lê um formato de origem externo, e um plugin importador traz conteúdo externo como entidades do Aggrega.
O espaço de formatos é aberto e pertence inteiramente aos plugins. Nenhum dos dois sockets contém uma lista de formatos que o compilador conheça: um plugin declara como capacidades os formatos que trata, e um novo formato é distribuído como um novo plugin, sem qualquer alteração ao compilador. Por isso esta interrupção comunica o conjunto anunciado tal como está em vez de uma enumeração fixa, e cada ausência é comunicada explicitamente: o pedido ou tem um plugin que o anuncie ou não pode ser satisfeito. Nada substitui um plugin em falta, com a única exceção dos analisadores que o compilador inclui, descrita abaixo.
Mensagens emitidas:
no parser plugin advertises the requested format: no parser plugin advertises "parse:<format>" (nenhum plugin analisador anuncia o formato pedido) no importer plugin advertises the requested format: no importer plugin advertises "import:<format>" (nenhum plugin importador anuncia o formato pedido)
Um único plugin analisador que anuncia o formato, mas contém uma estrutura de versão que não pode ser resolvida, é tratado como se nenhum plugin anunciasse o formato, em vez de passar silenciosamente, e indica-o:
no parser plugin advertises the requested format: no parser plugin version resolves for "parse:<format>" (nenhum plugin analisador anuncia o formato pedido: nenhuma versão de plugin analisador se resolve para o formato)
Uma análise recorre aos analisadores que o compilador inclui. Uma compilação analisa cada ficheiro que entrega a uma política render-verdict num formato que a política não lê nativamente, um importador lê a sua origem através do analisador da sintaxe que nomeia, e uma importação que não nomeia nenhum formato analisa a origem na sintaxe que cada assinatura aplicável nomeia. Para cada sintaxe, é utilizado o analisador que o catálogo do espaço de trabalho serve e, quando o catálogo não serve nenhum, o analisador que o próprio compilador inclui para ela — entre eles o analisador HCL através do qual uma compilação lê a saída do Terraform e o analisador JSON através do qual leem os importadores core do compilador, pelo que nem uma política sobre a saída do Terraform nem uma importação através de um importador core precisam de um analisador no catálogo. Quando o catálogo serve um analisador para uma sintaxe, o do compilador não tem qualquer papel, e dois de nomes diferentes no catálogo são recusados como descreve A parse or import format is advertised by more than one plugin (Um formato de análise ou de importação é anunciado por mais de um plugin). Assim, esta interrupção nomeia uma sintaxe para a qual nem o catálogo nem o compilador servem um analisador.
Como corrigir: confirmar que o formato está escrito tal como o plugin o anuncia — a capacidade é o prefixo do socket e o nome do formato, pelo que um plugin que anuncia parse:hcl serve o formato hcl e nada mais. Depois, confirmar que o plugin está presente no catálogo que a compilação lê. Quando não existe nenhum plugin para o formato, esse plugin é a peça em falta; o compilador não consegue ler um formato que nada anuncia.
A parse or import format is advertised by more than one plugin (Um formato de análise ou de importação é anunciado por mais de um plugin)
Dois ou mais plugins distintos anunciam o mesmo formato, e o pedido não pode ser encaminhado sem adivinhar qual usar.
Um catálogo que contenha ambos é válido e carrega sem objeções. Dois publicadores podem cada um distribuir um analisador ou um importador para um mesmo formato, e federar os seus catálogos é algo suportado. A ambiguidade é uma condição no ponto de utilização: provoca uma interrupção quando o formato disputado é efetivamente pedido, pelo que um par concorrente fora do alcance de uma compilação nunca a bloqueia.
Cada candidato é nomeado, por ordem, pelo que a mensagem é a mesma em cada execução.
Mensagens emitidas:
format is advertised by more than one parser plugin: format "<format>" is advertised by parser plugins [<plugin-names>] (o formato é anunciado por mais de um plugin analisador) format is advertised by more than one importer plugin: format "<format>" is advertised by importer plugins [<plugin-names>] (o formato é anunciado por mais de um plugin importador)
Para um importador, a interrupção é levantada numa estrutura adicional: as entradas plugins.importer do espaço de trabalho anexam mais do que um dos importadores que anunciam o formato, e os importadores que nomeia são então os anexados.
Os importadores entre os quais uma importação escolhe são os do catálogo do espaço de trabalho e os importadores core do compilador, que anunciam os seus formatos em qualquer espaço de trabalho. Assim, um catálogo que contenha o seu próprio importador com outro nome para um formato que um importador core serve — import:langflow ou import:flowise — depara-se com esta interrupção numa importação que não anexe nenhum dos dois, e a mensagem nomeia o importador core ao lado do importador do catálogo. Um importador que o catálogo contenha com o próprio nome de um importador core não é um segundo plugin a anunciar o formato: dentro de um mesmo nome é escolhida a versão mais alta, e um que esteja na versão própria do importador core, com o seu módulo ao lado, é executado em seu lugar. Um sem módulo ao lado não é candidato quando um importador com esse nome que possa ser executado anuncia o formato, como descreve Qual é executado ao lado dos importadores próprios.
Como corrigir: para um importador, manter ambos no catálogo — ou manter o próprio ao lado do importador core — e anexar aquele que se pretende — uma entrada plugins.importer cujo uri o nomeie pela sua identidade e versão, uri: importer/<name>:<version>, tal como aggrega plugin add importer a escreve. O importador anexado é escolhido entre os que anunciam o formato, tal como uma entrada plugins.providers escolhe entre os plugins que servem uma capacidade no socket fornecedor, descrito em «A capability is served by more than one provider plugin (Uma capacidade é servida por mais de um plugin fornecedor)» mais abaixo. Quando os importadores nomeados são os que as entradas existentes anexam, manter a entrada daquele que se pretende e remover a outra. O socket de análise não tem uma seleção deste tipo, pelo que, para um analisador, a solução é restringir o catálogo que a compilação lê para que só contenha o plugin pretendido — apontar --catalog para o diretório que contém a escolha feita é o caminho direto.
A plugins.importer entry pins a version of its importer the catalog does not hold (Uma entrada fixa uma versão do seu importador que o catálogo não contém)
Uma entrada plugins.importer anexa um importador pela sua identidade e uma versão — uma exata, uri: importer/<name>:1.2.0, ou um intervalo, uri: importer/<name>:^1.2.0 — e esse importador anuncia o formato que a importação pede, mas nenhuma versão dele entre as quais a importação escolhe satisfaz a fixação — as versões que o catálogo do espaço de trabalho contém e, para um importador core, também a versão do próprio compilador: a versão exata não está lá, ou nenhuma das suas versões cai no intervalo. A versão é uma escolha explícita, pelo que a importação é recusada antes de qualquer importador ser executado, em vez de se executar outra versão do importador no seu lugar.
Isto é distinto de nenhum importador anunciar o formato, descrito acima: aqui o importador é um daqueles entre os quais a importação escolhe e anuncia o formato, e só falta a versão que a entrada indica. Uma fixação que não tem nenhuma das formas que uma fixação de versão assume, como :latest, é antes comunicada como malformada, como descreve «A version pin is none of the forms a pin takes (Uma fixação de versão não tem nenhuma das formas que uma fixação assume)».
Mensagem emitida, que indica a capacidade do formato e a versão que a entrada fixa:
no importer plugin version satisfies the plugins.importer entry’s version pin: capability "import:<format>" pins "<version>" but no serving plugin version satisfies it (nenhuma versão de plugin importador satisfaz a fixação de versão da entrada plugins.importer: a capacidade fixa uma versão, mas nenhuma versão de plugin que a serve a satisfaz)
Como corrigir: altere a versão no uri da entrada para uma que o catálogo contenha — para um importador core, a versão do próprio compilador também conta —, ou alargue o intervalo, ou acrescente ao catálogo a versão que a entrada indica. Um intervalo caret corresponde a versões iguais ou superiores ao seu mínimo dentro da mesma versão major, pelo que ^2.0.0 não é satisfeito por um importador 1.x, por mais recente que seja.
A plugin reference carries a registry host or an artifact path (Uma referência de plugin contém um host de registo ou um caminho de artefacto)
Uma referência de Plugin começa com um segmento com a forma de um host de registo — um que contém um ponto ou dois pontos, como um nome DNS ou um par host e porta — ou com um caminho de artefacto. Um Plugin é endereçado pela sua identidade de coordenada: o seu tipo de plugin, uma barra, o seu nome e, opcionalmente, uma versão. O pull associa essa identidade a uma localização física prefixando o registo configurado e o próprio caminho do plugin, pelo que uma referência que já contenha um seria prefixada duas vezes e associada a uma localização que não pode ser obtida.
É recusada onde a localização é formada, e não na obtenção, para que a mensagem indique o que foi escrito em vez de surgir mais tarde como um erro de tag ilegível.
Mensagem emitida, enquadrada pelo pull que estava a formar a localização, com a solução na linha abaixo:
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 nível 3: a referência de plugin wasm tem de ser a identidade de coordenada do plugin, e não um caminho qualificado por registo nem um caminho 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 (correção: remova o host do registo e o caminho do artefacto, deixando apenas a coordenada; o pull prefixa ele próprio o registo configurado, pelo que uma referência que já contenha um é prefixada duas vezes)
Como corrigir: retire tudo o que precede o tipo de plugin, deixando a coordenada sozinha — provider/helm:1.0.0, e não hub.example.com/plugin/provider/helm:1.0.0. O registo do qual uma compilação faz pull é configuração do espaço de trabalho, e não parte de uma identidade, e é isso que permite servir um catálogo a partir de mais de um registo sem editar as entidades que contém.
A plugin or recipe reference carries no scope (Uma referência de plugin ou de receita não tem âmbito)
Uma referência de Plugin ou de Recipe não tem um segmento de âmbito inicial — nenhuma barra, ou um segmento vazio antes da barra, como em /name. Ambos os tipos são identificados por duas partes, e a primeira é o que mantém separadas duas entidades com o mesmo nome: um Plugin pelo seu tipo de plugin e o seu nome, uma Recipe pelo seu fornecedor e o seu nome. Dois sockets podem conter cada um um plugin chamado redact, e dois fornecedores podem distribuir cada um uma receita chamada postgres, pelo que o âmbito faz parte da identidade em vez de ser uma decoração.
Uma localização construída a partir de um âmbito vazio contém um segmento de caminho vazio — uma barra dupla — que não pode ser resolvido, pelo que a referência é recusada onde a localização é formada, em vez de ser deixada a falhar mais tarde como uma obtenção ilegível.
As duas soluções são o oposto do caso do plugin qualificado acima e uma da outra, e é por isso que cada uma é redigida à parte: aqui falta um segmento a uma referência e acrescenta-se um, enquanto uma referência qualificada tem um a mais e remove-se.
Mensagens emitidas, cada uma enquadrada pelo pull e com a sua própria solução por baixo:
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 nível 3: a referência de plugin wasm tem de ter um âmbito pluginType; um âmbito vazio não pode ser associado a uma localização 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 (correção: acrescente o segmento pluginType em falta — escreva a referência como tipo de plugin, barra e nome — utilizando o pluginType que a entidade do plugin declara)
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 nível 3: a referência de receita tem de ter um fornecedor como âmbito; um fornecedor vazio não pode ser associado a uma localização 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) (correção: nenhum diretório de catálogo local continha esta referência, pelo que foi procurada no registo, onde é obrigatório um segmento de fornecedor; execute novamente o pull indicando com a opção de catálogo o diretório que a contém, para que seja pesquisado primeiro; a opção pode ser repetida)
Como corrigir: para um plugin, prefixe o tipo de plugin que a entidade Plugin declara em metadata.pluginType. Para uma receita, prefixe o fornecedor que a Recipe declara em spec.capability. A solução para a receita indica uma segunda possibilidade que vale a pena ler: chegar ao registo significa que os diretórios de catálogo locais foram pesquisados primeiro e nenhum continha a referência, pelo que, se a receita deve vir de um diretório local, aponte a compilação para esse diretório em vez de acrescentar um âmbito.
The build consumes an artifact its publisher has deprecated (A compilação consome um artefacto que o seu publicador descontinuou)
Uma referência que esta compilação resolve tem um marcador de descontinuação registado pelo seu publicador, e a gravidade desse marcador é igual ou superior à gravidade que o espaço de trabalho configurou como limiar de interrupção. Um marcador é anexado a um artefacto publicado a posteriori, pelo que um artefacto que ontem compilava sem problemas pode ter um hoje sem que nada tenha mudado nos seus próprios ficheiros.
Comunicar e interromper são separados, e só a interrupção é configurável. Todos os marcadores registados são comunicados, em qualquer gravidade, e nenhuma configuração os silencia. Se um marcador também interrompe a compilação é o que halt_on_deprecated_severity decide, comparando a gravidade registada com o limiar configurado na ordem warning < error < retracted. Sem limiar configurado, nada é interrompido e cada marcador é um aviso. Uma gravidade fora das três, ou um limiar fora delas, nunca corresponde: um valor malformado não pode nem causar uma interrupção nem suprimir uma.
Todas as notificações são impressas antes de a compilação parar, não apenas a que a interrompeu, pelo que elevar o limiar nunca faz perder uma constatação — a própria interrupção indica a única referência em que parou. As constatações são ordenadas por referência, pelo que o mesmo ficheiro de bloqueio comunica a mesma sequência em cada execução e a que provoca a interrupção é sempre a mesma.
São verificados dois armazenamentos e ambos comunicam da mesma forma: as referências que o ficheiro de bloqueio fixa e os plugins registados como fidedignos para um veredicto de aceitar ou rejeitar. Nenhuma das verificações chega a um registo — ambas leem o que já estava registado —, pelo que a compilação se mantém ahead-of-time.
Mensagem emitida. Cada constatação é impressa à medida que é percorrida, e a interrupção repete depois a que atingiu o limiar e indica a definição que parou a compilação:
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" (descontinuação: a compilação consome uma entidade descontinuada: a referência foi retirada, com a mensagem registada pelo publicador (registada no ficheiro de bloqueio no pull; execute novamente o pull para a atualizar): halt_on_deprecated_severity tem o valor indicado)
Um marcador numa das duas gravidades de aviso é indicado como deprecated (warning) ou deprecated (error) em vez de retracted. A distinção mantém-se porque os dois significam coisas diferentes — desaconselhado mas ainda selecionável, por oposição a excluído da seleção — e comunicar o mais forte como o mais fraco subestimaria o que aconteceu.
Como corrigir: leia a mensagem registada, que é a explicação do próprio publicador sobre para onde migrar, e migre. Onde ainda não for possível migrar, elevar halt_on_deprecated_severity — ou remover a sua definição — volta a transformar a interrupção num aviso que continua a ser visto; trata-se de uma aceitação deliberada e não de uma solução de contorno, e a notificação continua a ser impressa. Um marcador registado para uma versão que já não é utilizada desaparece quando o ficheiro de bloqueio é atualizado com aggrega pull.
A trusted plugin’s recorded digest disagrees with the cached artifact (O digest registado de um plugin fidedigno diverge do artefacto em cache)
Um plugin anexado num papel que aceita ou rejeita uma compilação tem um digest registado como fidedigno, e o manifesto em cache do plugin comunica um diferente. Os dois são comparados antes de o executável do plugin ser lido, e uma divergência interrompe aí a resolução.
A comparação é o que faz do digest registado uma autoridade, e não uma repetição. Sem ela, os bytes de um plugin só são verificados contra uma fixação derivada do próprio manifesto cujos bytes ela depois valida — coerente consigo mesma por construção, e incapaz de notar que o artefacto inteiro foi substituído. Comparar o que foi registado com o que o manifesto comunica agora é o que dá a essa verificação uma opinião externa.
Isto é distinto de uma divergência do digest de conteúdo, que comunica bytes resolvidos em desacordo com o digest declarado para eles. Aqui nada foi lido, e os bytes podem perfeitamente concordar com o manifesto; o que diverge é qual artefacto está a ser resolvido. Manter os dois separados importa porque as soluções são opostas — um é um artefacto corrompido ou adulterado, o outro um plugin legitimamente alterado cuja nova identidade ainda não foi revista.
Mensagem emitida:
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 o plugin em cache: o digest registado como fidedigno para ele difere do que o manifesto do plugin na cache de conteúdo comunica; reveja o que mudou e registe novamente o digest fidedigno, ou restaure o artefacto registado: o digest registado como fidedigno para este plugin não corresponde ao digest que o seu manifesto em cache comunica)
Como corrigir: descubra o que mudou antes de voltar a registar o que quer que seja — este é um plugin que pode rejeitar as suas compilações, e o digest registado é a declaração de que alguém o examinou. Onde a mudança é esperada, porque o plugin foi atualizado deliberadamente, reveja o novo artefacto e registe novamente o digest fidedigno para ele. Onde não é esperada, restaure o artefacto registado; a divergência está a indicar que a identidade mudou sem que ninguém o decidisse.
An extends: chain cannot be assembled (Não é possível montar uma cadeia de extensão)
A cadeia extends: de um Component, de uma Feature, de um Manifest ou de uma Release indica um pai que não pode ser resolvido, pelo que a cadeia não pode ser transformada numa única entidade resolvida.
É distinta de um ciclo, que tem a sua própria condição e a sua própria solução — ver «Cyclic extends chain (Cadeia extends cíclica)» acima —; de uma cadeia para além do limite de profundidade, que tem a sua própria condição abaixo; e de uma fixação de versão impossível de satisfazer, em que o pai existe e só a versão não.
Mensagem emitida, que indica a entidade que contém o extends: impossível de resolver e a referência 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 (falha na fusão de herança: a entidade estende uma referência que nenhuma entidade do catálogo fornece. Verifique se a referência extends indica uma entidade presente no catálogo)
Quando a verificação que o reporta lê um pai da cache de artefactos segundo a fixação de um ficheiro de bloqueio — a verificação extends de uma compilação e de aggrega validate --release, aggrega validate sobre todo o catálogo e aggrega inspect, bem como as mesmas verificações executadas a partir do editor e da ferramenta validate do assistente —, a indicação prossegue nomeando o pull: «a base published to a registry is fetched by aggrega pull --release <release>» (uma base publicada num registo é obtida pelo comando indicado). Validar um único ficheiro de entidade não lê nenhum ficheiro de bloqueio, pelo que um pull não alteraria nada do que é lido, e a mensagem termina no catálogo.
Feature surge no lugar de Component quando a cadeia que falhou é a de uma Feature. Tal como num ciclo, a entidade indicada primeiro é aquela a partir da qual a resolução começou, e a entidade indicada na aresta é aquela cuja linha extends: deve ser aberta; ao longo de uma cadeia de vários níveis, as duas diferem.
O extends: de um Manifest é resolvido em relação a outro lugar, pelo que recebe outra orientação. Um Manifest é configuração do operador escrita ao lado da Release, e não conteúdo do catálogo, e o seu extends: indica um ficheiro por caminho relativo ou o metadata.name de um Manifest no próprio diretório da Release — nunca uma entidade do catálogo. Por isso, a sua mensagem termina com aquilo em que a referência não conseguiu ser resolvida e com onde procurar em alternativa:
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 (falha na fusão de herança: a entidade estende uma referência que não pôde ser resolvida. Verifique se a referência extends é um caminho relativo ou o nome de um Manifest no diretório da Release)
Esse detalhe final é a falha que a própria procura comunicou — o ficheiro que não pôde ser lido, ou a análise que não indexou nenhum Manifest com esse nome —, pelo que normalmente diz qual das duas formas foi tentada e porque é que não deu resultado.
O extends: de uma Release é resolvido em relação a um diretório e aceita uma única forma. Uma Release indica o seu pai como um caminho relativo — ./base-release.yaml, ou ../shared/base-release.yaml. O diretório em relação ao qual é resolvido é o que contém a Release que escreve a referência, e cada elo de uma cadeia é resolvido em relação ao seu próprio diretório — assim, uma Release a meio da cadeia guardada num subdiretório indica o seu pai ao seu lado, onde quer que esteja a Release que um comando indica. Um token simples não é um caminho e não indica uma Release que o compilador vá procurar, pelo que é comunicado aqui em vez de ser procurado num lugar onde não pode ser encontrado:
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 (falha na fusão de herança: a entidade estende uma referência que não pôde ser resolvida. Verifique se a referência extends é um caminho relativo para um ficheiro de Release, como ./base-release.yaml, resolvido a partir do diretório que contém esta Release)
Como corrigir: para um Component ou uma Feature, confirme que o valor de extends: indica uma entidade que o catálogo contém, escrita como o próprio metadata.name dessa entidade — incluindo maiúsculas e minúsculas. Uma base publicada num registo é lida da cache de artefactos segundo a fixação que o ficheiro de bloqueio da Release regista para ela; assim, quando a base se encontra num registo, execute aggrega pull --release <release>: o pull segue a cadeia, obtém a base e fixa-a. Para um Manifest, confirme que o ficheiro está onde o caminho relativo aponta, ou que um Manifest com esse metadata.name se encontra no diretório da Release e é analisado corretamente. Para uma Release, confirme que o valor começa por ./ ou ../ e que o ficheiro para o qual aponta existe e é analisado como uma Release.
An extends: chain runs past the depth bound (Uma cadeia de extensão ultrapassa o limite de profundidade)
A cadeia extends: de um Component, de uma Feature, de um Manifest ou de uma Release termina corretamente, mas passa por mais entidades do que o limite de dez permite.
Tem uma condição própria em vez de partilhar a de cima, porque as duas soluções não têm nada em comum: um pai ausente é uma referência a corrigir, e uma cadeia demasiado profunda é uma estrutura a aplanar. O limite é uma proteção contra um acidente de autoria, e não um limite estrutural — os arquitetos estendem normalmente uma base em um ou dois níveis, e uma cadeia com dez níveis de profundidade é habitualmente uma árvore base que foi crescendo, e não um design deliberado.
Só uma cadeia que TERMINA chega a ela. Uma cadeia que volta sobre si mesma é comunicada como um ciclo, qualquer que seja o seu comprimento, pelo que esta condição nunca substitui um ciclo e a sua orientação — encurtar a cadeia — nunca é dada para um.
Mensagem emitida, que indica o limite e o comprimento que a cadeia atingiu:
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 (a cadeia extends excede a profundidade máxima. o limite é 10 e esta cadeia vai além dele; encurte a cadeia, ou estenda uma base que esteja mais perto da sua raiz)
Feature, Manifest ou Release surge no lugar de Component quando uma dessas cadeias é a que falhou. O limite é o mesmo dez para cada tipo que declara extends, e conta as entidades da cadeia, e não os elos entre elas: uma cadeia de exatamente dez entidades compila, e a décima primeira entidade é o que isto comunica. Assim, uma entidade que estende uma base que estende uma base — três entidades, dois elos — chegou a três.
Como corrigir: condense o meio da cadeia. Uma cadeia tão profunda significa normalmente que cada nível acrescenta pouco, e juntar vários níveis numa única entidade base é simultaneamente a correção e a estrutura mais clara. Onde os níveis são realmente distintos, uma entidade mais abaixo na cadeia pode estender diretamente uma base mais perto da raiz em vez de herdar através de cada nível intermédio. Uma cadeia de Manifest tão profunda é normalmente uma pilha de sobreposições por ambiente — junte os níveis que ninguém varia na base que eles sobrepõem.
An assertion name is declared twice along an extends: chain (Um nome de asserção é declarado duas vezes ao longo de uma cadeia de extensão)
Uma entidade e algo que ela estende declaram ambos uma asserção com o mesmo nome, e as duas declaram regras diferentes. As asserções de uma entidade que estende somam-se às da sua base; nunca substituem nenhuma. Assim, um nome declarado duas vezes com duas regras diferentes retiraria silenciosamente o invariante da base, o que é o oposto daquilo para que serve estender uma entidade.
Declarar o mesmo nome com a regra idêntica não é uma colisão e compila. É isso que mantém a verificação idempotente ao longo de uma cadeia: sem isso, uma cadeia de três níveis colidiria sempre com o seu próprio nível intermédio.
A ordem faz parte do contrato, e não é acessória. As asserções são avaliadas na ordem fundida e a primeira que falha provoca a interrupção, pelo que o invariante de uma base é verificado antes do de um descendente, e ao longo de uma cadeia o conjunto acumula-se da raiz para baixo.
Mensagem emitida:
assertion name declared twice across the extends chain (Component <name>:<version>, rule assertions, at .spec.assertions.<key>). assertion "<key>" is already declared by the base Component "<base>", carrying a different rule; rename the extending entity’s assertion; an extending entity’s assertions add to the base’s and never replace one (nome de asserção declarado duas vezes ao longo da cadeia extends. a asserção já é declarada pelo Component base, com uma regra diferente; mude o nome da asserção da entidade que estende; as asserções de uma entidade que estende somam-se às da base e nunca substituem nenhuma)
Como corrigir: mude o nome da asserção da entidade que estende, que a mensagem indica juntamente com a base que já a declara. Onde se pretendia substituir a regra da base, isso não é algo que a extensão admita — restrinja a asserção da base para que se verifique em todas as entidades que a estendem, ou mova a regra para baixo, para as entidades que realmente precisam dela. Onde as duas regras devem ser iguais, torne-as textualmente idênticas e a colisão desaparece.
A Release chain’s links disagree about the routing shape (Os elos de uma cadeia de Release divergem quanto à estrutura de encaminhamento)
Uma Release encaminha os componentes do seu Aggregate de uma de duas maneiras: fronteiras com nome sob boundaries:, ou componentes de nível superior sob components:. As duas excluem-se mutuamente, e um único documento que declare ambas é recusado logo na leitura. Esta condição é a mesma regra ao longo de uma cadeia extends:: uma base que declara fronteiras com nome e um filho que declara componentes de nível superior estão, cada um, bem formados por si sós, e só ao fundi-los é que as duas escolhas se reúnem numa única Release resolvida.
Nenhum dos dois documentos está errado por si só, e é por isso que a mensagem nomeia ambos e ambas as chaves. Um diagnóstico que nomeasse apenas a Release para a qual a compilação foi apontada enviaria o leitor para o ficheiro que não tem nada de errado.
Uma cadeia cujos elos concordam não é afetada. Cada elo que declara fronteiras com nome compõe-se normalmente, tal como cada elo que declara componentes de nível superior. É a mistura que para.
Mensagem emitida, que nomeia os dois ficheiros e a chave que cada um declara:
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>") (a cadeia de extensão da Release compõe tanto fronteiras com nome como componentes de nível superior: declare uma única estrutura de encaminhamento em toda a cadeia, nunca ambas — Release, ficheiro que declara as fronteiras, ficheiro que declara os componentes)
Como corrigir: escolha-se a estrutura de encaminhamento que a cadeia deve usar e escreva-se essa estrutura em toda a cadeia. Onde a base declara fronteiras com nome, um filho que pretenda configurar componentes endereça-os dentro da fronteira que os contém, e não na raiz da Release — e é também isso que lhe permite alterar o dimensionamento de um componente sem voltar a declarar a topologia. Onde a base declara componentes de nível superior, um filho que precisa de fronteiras com nome está a descrever uma estrutura de encaminhamento diferente da da sua base, e é preferível escrevê-lo como uma Release própria do que como filho dessa.
An external input’s URL uses a scheme that is not allowed (O URL de uma entrada externa usa um esquema não permitido)
Um URL para o qual uma entidade aponta usa um esquema fora do conjunto permitido. São permitidos três: https; http, mas apenas para um host de loopback, de modo que o texto não cifrado só possa alguma vez chegar à máquina local; e oci, para conteúdo obtido de um registo.
Mensagens emitidas, para um URL http que não é de loopback e para qualquer outro 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 não cifrado só é permitido para hosts de loopback (esquemas permitidos: https, http para um host de loopback, oci): externalinputs: o esquema do URL não é permitido) externalinputs: "<url>": scheme "<scheme>" is not allowed (allowed schemes: https, http to a loopback host, oci): externalinputs: URL scheme is not allowed (externalinputs: o esquema não é permitido (esquemas permitidos: https, http para um host de loopback, oci): externalinputs: o esquema do URL não é permitido)
Como corrigir: mude-se o URL para https, ou para oci quando o conteúdo estiver publicado num registo. Um URL http não cifrado para um host remoto é recusado em vez de rebaixado, pelo que a correção é apontá-lo para o esquema seguro; um servidor de desenvolvimento local continua a funcionar sobre http porque um host de loopback é permitido.
A render requests an external input the lockfile does not pin (Uma renderização pede uma entrada externa que o ficheiro de bloqueio não fixa)
Algo de que uma compilação precisa é obtido de um URL que o ficheiro de bloqueio não fixa. Uma compilação renderiza o fecho que o seu ficheiro de bloqueio regista e não obtém nada, pelo que não existe nenhuma definição que permita a esta execução adquirir o URL em vez disso: o fecho congelado é o que torna uma compilação reproduzível, e alargar discretamente o conjunto de entradas é a única coisa que não pode fazer.
Chegar a esta interrupção é, por isso, informativo e não um erro de configuração. As fixações estavam completas quando a Release foi resolvida, pelo que um URL não fixado significa agora que algo mudou desde então — um valor que orienta as referências que uma renderização pede, um chart que começou a apontar para outro lado, ou um ficheiro de bloqueio resolvido em relação a uma Release diferente.
Mensagem emitida:
"<url>" is not pinned in the lockfile; run aggrega pull --release <release> to pin every external input this Release’s render consumes, then build again: externalinputs: acquisition is disabled for unpinned inputs (não está fixado no ficheiro de bloqueio; execute o comando para fixar todas as entradas externas que a renderização desta Release consome e volte a compilar: externalinputs: a aquisição está desativada para entradas não fixadas)
Como corrigir: fixe-se a entrada. aggrega pull --release <path> renderiza a Release para descobrir que entradas externas consome, obtém cada uma delas e regista o seu digest no ficheiro de bloqueio ao lado das fixações de dependências — após o que cada compilação posterior a serve a partir do registo fixado e não precisa de rede nenhuma. Quando o URL é novo porque algo que foi escrito começou a apontar para ele, voltar a resolver a Release é o passo que ficou por fazer; quando é inesperado, vale a pena encontrar a referência que o introduziu antes de o fixar.
Fetched bytes do not match a pinned digest (Os bytes obtidos não correspondem a um digest fixado)
Um URL fixado foi obtido de novo — porque a sua cópia armazenada estava em falta — e o que voltou não é o que o ficheiro de bloqueio fixou. O digest registado prevalece sempre: nada é escrito no armazenamento e nenhum byte é devolvido.
Uma recarga é obtida pelo digest registado e não pela tag do URL, pelo que uma tag que tenha sido movida para apontar para outro conteúdo não pode alterar o que uma entrada fixada serve. Chegar a esta interrupção significa, por isso, que foi o próprio conteúdo por trás do digest que não voltou intacto.
Mensagens emitidas, para conteúdo obtido de um registo e para conteúdo obtido através de HTTPS:
externalinputs: "<url>": refilled manifest digest is <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs: o digest do manifesto recarregado difere do digest fixado: externalinputs: os bytes obtidos não correspondem ao digest fixado) externalinputs: "<url>": refetched bytes hash to <digest>, pinned digest is <digest>: externalinputs: fetched bytes mismatch the pinned digest (externalinputs: o hash dos bytes obtidos de novo difere do digest fixado: externalinputs: os bytes obtidos não correspondem ao digest fixado)
Como corrigir: trate-se primeiro como uma questão de cadeia de abastecimento e não como um ficheiro de bloqueio a atualizar — a fixação é a afirmação de que exatamente estes bytes eram aquilo com que a compilação foi feita, e a recusa é essa afirmação a manter-se. Confirme-se que a origem ainda publica o conteúdo que o digest nomeia e verifique-se se algo entre o utilizador e a origem está a reescrever as respostas; um proxy ou um espelho a servir um substituto é uma causa comum. Só depois de saber o que mudou e de o aceitar se deve fixar de novo com aggrega pull, que regista o novo digest.
A stored external input no longer matches its record (Uma entrada externa armazenada já não corresponde ao seu registo)
Uma entrada fixada foi relida do armazenamento local e não corresponde ao registo fixado para ela. A verificação é executada em cada leitura, antes de os bytes serem servidos, pelo que um armazenamento corrompido ou adulterado se revela no ponto de utilização, em vez de alimentar discretamente uma compilação.
O que é comparado depende da forma como a entrada é fixada. O conteúdo obtido através de HTTPS é fixado calculando o hash do payload, pelo que o hash é recalculado em cada leitura e ambos os digests são comunicados. O conteúdo obtido de um registo é fixado pelo digest do seu manifesto, que compromete o payload através do próprio manifesto do registo em vez de calcular diretamente o seu hash, pelo que uma cópia armazenada é verificada em relação ao tamanho registado — a verificação completa do digest ancora-se, em vez disso, na aquisição e em cada recarga endereçada por digest.
Mensagens emitidas:
externalinputs: "<url>": store blob sha256 is <digest>, pinned digest is <digest>: externalinputs: store blob mismatches its pinned record (externalinputs: o sha256 do blob no armazenamento difere do digest fixado: externalinputs: o blob no armazenamento não corresponde ao seu registo fixado) externalinputs: "<url>": store blob sha256/<digest> is <n> bytes but the pinned record says <n>: externalinputs: store blob mismatches its pinned record (externalinputs: o tamanho em bytes do blob sha256 no armazenamento difere do que o registo fixado indica: externalinputs: o blob no armazenamento não corresponde ao seu registo fixado)
Como corrigir: elimine-se do armazenamento o blob em causa e deixe-se a execução seguinte recarregá-lo a partir da origem, o que é verificado em relação ao digest registado antes de qualquer escrita. Se uma recarga também comunicar então uma divergência de digest, o desacordo está a montante e não no local, e a entrada acima é a que deve ser lida. Um armazenamento partilhado entre máquinas, ou um restaurado a partir de uma cópia de segurança feita a meio de uma escrita, é a causa local habitual.
A guard needs a catalog entity the build resolved and cannot see (Uma guarda precisa de uma entidade do catálogo que a compilação resolveu e que ela não consegue ver)
Uma guarda semântica procurou a entidade do catálogo por trás do tipo de um componente, e a entidade está ausente da vista que a guarda recebeu — embora a resolução tenha resolvido esse tipo como uma referência ao catálogo. Uma referência genuinamente impossível de resolver é interrompida mais cedo, na resolução, pelo que chegar a uma guarda com a entidade em falta significa que o conjunto resolvido da compilação e a vista da guarda se separaram.
A compilação para em vez de saltar a guarda. Saltá-la retiraria uma verificação sem nada que indicasse que deixou de existir, e os componentes de que a guarda tratava passariam sem exame enquanto a compilação comunicaria sucesso.
Um tipo escrito como caminho relativo — a começar por ./ ou ../ — não é avaliado aqui: um tipo nunca é lido como ficheiro, pelo que um valor desses não nomeia nenhuma entidade do catálogo e é recusado mais cedo, quando as dependências da Release são resolvidas, como uma referência que nenhum catálogo contém. Só uma referência ao catálogo na forma de token simples chega a esta interrupção.
Onde quer que a condição se verifique, é comunicada com as mesmas palavras, pelo que o texto nomeia o tipo e o defeito e não a verificação que o gerou.
Também não nomeia nenhum documento nem nenhuma chave dentro de um, o que é deliberado e é o único ponto em que esta interrupção se lê de forma diferente de todas as outras. Todas as outras interrupções se posicionam no ficheiro e no campo que seria preciso editar para as eliminar; aqui não existe tal ficheiro, pelo que uma posição enviaria o leitor para uma chave que não tem culpa. Em vez disso, é comunicado o tipo sobre o qual as duas vistas divergem, porque é isso que torna a divergência reproduzível para quem a investigar.
Mensagem emitida:
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>") (as próprias vistas do compilador sobre o catálogo divergem (erro interno: esta compilação resolveu um tipo de componente para o qual o catálogo que lê não tinha depois nenhuma entrada. Trata-se de um defeito no compilador e não num documento escrito por um autor, pelo que não há nada a corrigir no Aggregate, na Release ou no catálogo. Comunique-a, indicando o comando que produziu esta compilação e o tipo sobre o qual as vistas divergem))
Como corrigir: nada nos próprios ficheiros — isto comunica uma incoerência dentro do compilador e não um defeito no que foi escrito, e vale a pena comunicá-la como uma anomalia com o tipo que a mensagem nomeia. O tipo do componente está quase certamente correto.
A reference names no entity the catalog holds (Uma referência não nomeia nenhuma entidade que o catálogo contenha)
Antes de uma compilação renderizar o que quer que seja, todo o conjunto de entidades de que uma Release depende é percorrido e cada uma é fixada, de modo que o ficheiro de bloqueio registe exatamente o que a compilação vai ler. Uma referência a que o catálogo não consegue responder interrompe esse percurso: nada pode ser fixado para ela, e continuar escreveria um ficheiro de bloqueio sem uma entrada de que a compilação vai precisar mais tarde, sem nada que o indicasse.
A recusa nomeia a referência e o ponto onde foi recolhida, porque uma entidade é alcançada a partir de muitos pontos e o ponto que a nomeia é onde a correção tem de ser feita. Uma referência a biblioteca é comunicada sozinha, sem caminho de recolha — uma biblioteca é alcançada a partir das entidades que a referenciam com $ref ou $import, e o nome que falha é todo o defeito.
Mensagem emitida, para uma entidade do catálogo — a parte final lista os pontos que a referenciam:
resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from <referring paths>) (resolve: nenhuma entidade do catálogo corresponde a este URI: entidade, com os caminhos a partir dos quais é referenciada)
para uma biblioteca:
resolve: no entity in the catalog matches this URI: library "<reference>" (resolve: nenhuma entidade do catálogo corresponde a este URI: biblioteca)
e para um plugin associado a um socket de fornecedor, que é nomeado pela chave de configuração do espaço de trabalho que o continha e não por um documento do catálogo:
resolve: no entity in the catalog matches this URI: entity "<reference>" (referenced from .aggrega-config.yaml.plugins.providers) (resolve: nenhuma entidade do catálogo corresponde a este URI: entidade, referenciada a partir de .aggrega-config.yaml.plugins.providers)
Quando um ficheiro sob os diretórios de catálogo declara o nome que a referência pede sob um tipo de entidade que nenhum catálogo contém — um kind mal escrito, por exemplo —, a nota por baixo desta falha nomeia esse ficheiro, o tipo que declara e os tipos que um catálogo contém, e omite o conselho sobre onde são lidas as entidades locais, tanto numa compilação que preenche o seu ficheiro de bloqueio como numa que o lê, e em qualquer outra superfície que comunique esta falha; consulte-se Um ficheiro do catálogo recusado e a falha que explica.
Como corrigir: leia-se a referência exatamente como a mensagem a cita. Um nome que não existe, uma versão que nunca foi publicada e um nome simples para cujo registo o espaço de trabalho não aponta chegam todos aqui de forma idêntica, pelo que se devem verificar os três por esta ordem: corrigir a grafia; confirmar que a versão existe; confirmar que o registo que a contém está configurado e acessível. Quando a entidade é uma que é escrita localmente, confirme-se que o ficheiro está dentro do catálogo que a compilação percorre.
Quando aggrega pull, ou aggrega build --auto-pull, para numa referência a biblioteca enquanto a cache de artefactos contém uma SchemaLibrary que nenhuma entrada do ficheiro de bloqueio fixa e que nenhum diretório de catálogo fornece, segue-se à mensagem uma linha remediation: que nomeia cada uma dessas bibliotecas. Uma biblioteca em cache só conta como conteúdo do catálogo quando uma entrada do ficheiro de bloqueio garante o seu digest, e o pull regista essa entrada a partir do registo que serve a biblioteca. No modo offline, o pull não pode obter a biblioteca nem registar uma entrada para ela, pelo que a linha indica que se execute aggrega pull --release <release> onde seja possível chegar a um registo, ou que se escreva a biblioteca sob um diretório de catálogo. Com ligação, nenhum diretório de catálogo nem registo que o pull lê serve a biblioteca, pelo que não há entrada a registar, e a linha indica que se escreva a biblioteca sob um diretório de catálogo.
A library reference is not written in the identity form (Uma referência a biblioteca não está escrita na forma de identidade)
Um $ref: ou $import: entre bibliotecas nomeia a biblioteca pela sua identidade e depois a entrada dentro dela: o nome simples da biblioteca, opcionalmente um : e uma versão mínima, depois # e o caminho da entrada na superfície que o campo lê. Não há host de registo nessa forma. O registo através do qual um nome é resolvido é configuração do espaço de trabalho, e a versão que uma compilação usa é a resposta do ficheiro de bloqueio, pelo que uma referência que trouxesse qualquer um dos dois fixaria no documento algo que cabe à compilação decidir.
São recusados aqui: um valor que traz um host de registo; uma âncora interna ao documento escrita onde se esperava uma referência entre bibliotecas; um nome de biblioteca vazio; e @ escrito como separador de versão, que é comunicado com a grafia corrigida em vez de como uma queixa genérica sobre a estrutura, porque é o erro que esta forma mais atrai.
Mensagem emitida:
resolve: invalid library reference URI: "<the value as written>" (resolve: URI de referência a biblioteca inválido)
e quando @ foi usado como separador, citando o que o valor deveria conter em vez disso:
resolve: invalid library reference URI: version separator is ’:’, not ’@’ — use "<the corrected value>" (resolve: URI de referência a biblioteca inválido: o separador de versão é ’:’, não ’@’ — use-se o valor corrigido)
Como corrigir: reescreva-se o valor como <Library>#<entry-path>, acrescentando :<version> após o nome da biblioteca apenas onde for preciso um mínimo para a versão que pode ser selecionada. Remova-se qualquer host de registo. Quando a referência devia apontar para dentro do mesmo documento, uma âncora interna ao documento é algo diferente de uma referência a biblioteca, e o campo onde foi escrita espera a forma de biblioteca.
Two consumers of one library require incompatible versions (Dois consumidores de uma mesma biblioteca exigem versões incompatíveis)
Várias entidades podem referenciar uma mesma biblioteca, cada uma a indicar uma versão mínima ou nenhuma, e a versão que a compilação seleciona é a versão mínima mais alta indicada por qualquer uma delas. É isso que permite que um consumidor que pede menos receba ainda assim uma versão que o satisfaz, e é por isso que acrescentar um consumidor com uma versão mínima mais alta faz subir todos em vez de dividir a compilação entre duas cópias.
A regra só se mantém enquanto as versões mínimas concordarem no número de versão inicial. Dois consumidores que indicam versões principais diferentes estão a pedir duas bibliotecas que por acaso partilham o nome, e nenhuma seleção única satisfaz ambas — por isso, em vez de escolher uma e deixar o outro consumidor ler uma estrutura para a qual não foi escrito, a compilação para e indica a divergência. Um consumidor que não indica nenhuma versão mínima não participa em nada aqui: a seleção é decidida pelos consumidores que fixaram uma versão.
Mensagem emitida. Os consumidores são comparados por ordem, depois de ordenados: o primeiro a indicar uma versão mínima define a versão principal, e a mensagem enumera cada consumidor comparado, até ao primeiro, inclusive, cuja versão mínima indica uma versão principal diferente, juntamente com a versão que exigia — assim, os mesmos documentos nomeiam sempre os mesmos consumidores:
resolve: minimal version selection conflict — incompatible library version requirements: library "<library>" has consumers requiring incompatible majors: <consumer> wants <version>; <consumer> wants <version> (resolução: conflito na seleção de versão mínima — requisitos de versão de biblioteca incompatíveis: a biblioteca tem consumidores que exigem versões principais incompatíveis: o consumidor quer a versão; o consumidor quer a versão)
Como corrigir: suba a versão mínima do consumidor mais baixo para a mesma versão principal, que é a resposta habitual quando a estrutura mais recente é a que todos querem. Quando ambas as versões principais são realmente necessárias ao mesmo tempo, trata-se de duas bibliotecas: publique a estrutura mais antiga com um nome próprio e faça o consumidor que precisa dela apontar para lá, para que cada referência nomeie aquilo para que foi escrita.
The chain of module imports is deeper than the pin walk descends (A cadeia de importações de módulos é mais profunda do que o percurso de fixação desce)
A fixação percorre cada módulo que um Aggregate importa e depois cada módulo que esses importam, de modo que o conjunto completo chega ao ficheiro de bloqueio, e não apenas o primeiro nível. Um módulo já registado não é percorrido uma segunda vez, e é isso que põe fim a um ciclo comum — um Aggregate que importa um módulo que, por sua vez, o importa termina sem queixa, depois de ter registado cada um uma única vez.
Um limite de profundidade de dez serve de salvaguarda para a cadeia que a deteção de repetições não consegue ver: uma que apresenta uma identidade nova em cada nível, como faz um módulo republicado com uma nova versão em cada passo. O limite é o mesmo que o construtor do grafo aplica, pelo que uma composição que pode ser fixada é também uma composição que pode ser construída.
Mensagem emitida:
resolve: sub-aggregate inclusion depth exceeded: "<module>" at depth <depth> (resolução: profundidade de inclusão de subagregados excedida: na profundidade)
Como corrigir: encurte a cadeia. Uma cadeia tão profunda reflete normalmente a forma como uma organização está estruturada, e não a forma como a Release está estruturada, por isso procure níveis que não contribuem com componentes próprios e funda-os no seu pai. Quando cada nível existe apenas para republicar o nível abaixo com uma nova versão, as versões são a cadeia: importe diretamente o módulo que realmente pretende, na versão que pretende.
Este é o limite do percurso de fixação. O construtor do grafo aplica o seu próprio, comunicado mais abaixo como «Sub-aggregate nesting depth exceeded (Profundidade de aninhamento de subagregados excedida)», e os dois são comunicações separadas do mesmo limite atingido em dois pontos — a primeira enquanto o ficheiro de bloqueio está a ser preenchido, a segunda enquanto o grafo está a ser construído.
The catalog view a build was given cannot load the bodies pinning needs (A vista do catálogo fornecida a uma compilação não consegue carregar os corpos de que a fixação precisa)
Dois dos eixos que a fixação percorre precisam de mais do que uma resposta de versão do catálogo: precisam dos próprios documentos. Os módulos que um Aggregate importa têm de ser lidos para encontrar o que eles importam por sua vez. As Recipes, FeatureRecipes e Plugins que uma compilação associa têm de ser lidos para encontrar os artefactos e as bibliotecas que eles nomeiam. Uma vista do catálogo que consegue resolver uma versão, mas não consegue devolver esses corpos, deixa ambos os eixos sem nada para ler.
Ambos são recusados à partida em vez de ignorados, e o motivo é o que um salto produziria: um ficheiro de bloqueio sem uma classe inteira de entradas, escrito sem queixa, que uma compilação posterior reconstrói fielmente e encontra incompleto. Nenhuma das mensagens contém valores próprios, porque nenhuma diz respeito a um documento que tenha escrito — cada uma indica que eixo não pode ser calculado:
resolve: catalog lookup cannot load resolved sub-aggregate bodies (resolução: a consulta ao catálogo não consegue carregar os corpos dos subagregados resolvidos) resolve: catalog lookup cannot load resolved recipe and plugin bodies (resolução: a consulta ao catálogo não consegue carregar os corpos de Recipe e de plugin resolvidos)
Como corrigir: nada nos seus ficheiros produz nenhuma das duas, e não existe nenhuma alteração ao que escreveu que elimine uma delas — o defeito está na forma como a compilação foi montada, e não no que lhe foi pedido que construísse. Comunique-o indicando o comando que executou e a configuração do espaço de trabalho com que foi executado.
An annotation-transform plugin names a component it was not given, or injects a value no annotation takes (Um plugin annotation-transform nomeia um componente que não lhe foi entregue, ou injeta um valor que nenhuma anotação aceita)
Um operador pode anexar um plugin de governação num papel que acrescenta anotações, e esse anexo é uma declaração: o operador pediu a transformação, pelo que o que o plugin acrescenta é explícito, e não injetado nas costas de ninguém. O papel está delimitado em conformidade. O plugin recebe as coordenadas de componentes que os seus documentos declaram e pode acrescentar anotações sobre elas, cada uma com um valor que poderia ter escrito nessa anotação: uma string ou um objeto de subchaves. A estrutura que devolve não admite nenhum outro campo, pelo que o que resta verificar quando a sua saída é aplicada é se cada injeção nomeou uma coordenada que lhe foi entregue e se cada valor é um que uma anotação aceita.
Uma injeção que nomeia um par de fronteira e componente fora desse conjunto interrompe a compilação. Um plugin que alcançasse um componente que os seus documentos nunca expuseram estaria a configurar infraestrutura que ninguém declarou, e as anotações que acrescenta são expandidas em anexos de Feature exatamente como as escritas pelo autor, pelo que o efeito seria o aparecimento de recursos a partir de um componente que o operador não lhe pôs à frente.
Uma injeção cujo valor é null, uma lista, um número, um booleano ou um objeto sem subchaves também interrompe a compilação. Null e um objeto vazio são lidos como o valor que se escreve para excluir um componente de uma anotação que herdaria, e o papel acrescenta anotações em vez de as remover; as outras estruturas não são valores que uma anotação aceite. Toda a saída é verificada antes de qualquer parte dela ser aplicada, pelo que uma saída recusada não altera nada.
Cada injeção aceite contém também uma anotação acompanhante, aggrega.ai/injected-by, que nomeia o plugin que a fez. É o host que escreve essa anotação; um plugin não pode fornecer uma, pelo que o que ela diz sobre a origem de uma anotação injetada não cabe ao plugin moldar.
Mensagem emitida, para uma coordenada que não foi entregue ao plugin e para um valor que nenhuma anotação aceita:
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>") (a saída do plugin annotation-transform foi rejeitada: uma injeção visa uma coordenada de componente que o host não forneceu, ou contém um valor que não é uma string nem um objeto de subchaves: a injeção visa a fronteira, componente (anotação)) 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 (a saída do plugin annotation-transform foi rejeitada: uma injeção visa uma coordenada de componente que o host não forneceu, ou contém um valor que não é uma string nem um objeto de subchaves: a injeção para a fronteira, componente (anotação) contém uma lista; um valor de anotação injetado é uma string ou um objeto de subchaves)
Como corrigir: o defeito é do plugin, e não dos seus documentos — corrija-o para que injete apenas nas coordenadas que lhe são entregues, cada uma das quais chega na sua entrada, e apenas uma string ou um objeto de subchaves como valor. Se o componente na mensagem for um que esperava que o plugin visse, verifique se a Release o declara dentro de uma fronteira: só são passadas as coordenadas de componentes declarados. Remover o anexo de plugins.governance é a forma imediata de desbloquear uma compilação enquanto o plugin é corrigido.
A plugin reference is not a Plugin entity (Uma referência de plugin não é uma entidade Plugin)
Um plugin é referenciado pela sua entidade Plugin, sempre com o âmbito do próprio tipo de socket do plugin: <pluginType>/<name>, opcionalmente com uma versão, como em parser/yaml ou parser/yaml:1.0.0. O âmbito é obrigatório, e não uma forma entre várias — um name:version sem âmbito é recusado, porque dois sockets podem conter um plugin com o mesmo nome e é o âmbito que torna a entidade resolúvel. O binário para que a entidade aponta é alcançado através da entidade, nunca nomeado diretamente, pelo que é a entidade que contém a declaração de capacidade, os limites de execução e o conjunto de comandos registado com que o carregamento verifica o binário. Uma referência que não nomeia nenhuma entidade Plugin não tem, portanto, nada com que verificar o binário, e a compilação para em vez de carregar bytes a partir de uma referência não verificada.
Duas estruturas são comunicadas aqui, e são verificadas em momentos diferentes. Uma referência cuja forma não pode ser uma entidade — um caminho do sistema de ficheiros, ou uma referência de artefacto como um URL oci://, um .wasm simples ou um digest @sha256: — é recusada à partida nas superfícies que aceitam apenas referências de entidade. Uma referência que não nomeia nenhuma entidade que algo contenha é recusada após a consulta, e o que a mensagem diz depende da forma como está escrita: um URI de entidade Plugin — <pluginType>/<name>, opcionalmente com versão — é comunicado como uma entidade que nenhum diretório de catálogo contém, que o binário não inclui e que nenhum pull obteve, e a qualquer outra referência é indicado que adote essa forma. Ambas as estruturas comunicam a mesma condição, pelo que a resposta de uma compilação a qualquer uma delas é a mesma.
Um pull recusa a segunda estrutura antes de uma compilação a encontrar. Cada Plugin que a pipeline de uma Recipe ou de uma FeatureRecipe nomeia é resolvido juntamente com as restantes dependências da Release — a partir de um diretório de catálogo, da cópia dentro do binário do compilador, da cache de conteúdo ou de um registo — e um que nenhum deles contenha interrompe o aggrega pull antes de este escrever o ficheiro de bloqueio, com esta condição e a mesma mensagem, nomeando a Recipe ou a FeatureRecipe cuja pipeline o nomeia.
Nem todas as superfícies recusam uma forma que não é uma entidade. A superfície de plugins de pipeline aceita apenas referências de entidade; as superfícies às quais um operador anexa um plugin diretamente aceitam qualquer forma e passam uma referência que não é uma entidade para ser resolvida como artefacto. Assim, a mesma referência pode ser aceite num ponto de anexo e recusada noutro, e essa diferença é da superfície, e não da referência.
Mensagens emitidas. Um caminho do sistema de ficheiros:
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) (a referência de plugin não é uma entidade Plugin: é um caminho do sistema de ficheiros, mas um plugin de pipeline tem de ser um URI de entidade Plugin com âmbito de tipo de plugin (opcionalmente com versão))
uma referência de 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) (a referência de plugin não é uma entidade Plugin: é uma referência de artefacto (um esquema de URL, um ficheiro Wasm simples ou um digest), mas um plugin de pipeline tem de ser um URI de entidade Plugin com âmbito de tipo de plugin (opcionalmente com versão))
um URI de entidade Plugin que nada contém:
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 (a referência de plugin não é uma entidade Plugin: é um URI de entidade Plugin, mas nenhum diretório de catálogo contém a entidade que nomeia, o binário não a inclui e nenhum pull a obteve para a cache de conteúdo; coloque a entidade Plugin num diretório de catálogo, ou publique-a num registo e execute o pull)
e qualquer outra referência que não nomeie nenhuma entidade — uma sem âmbito de tipo de plugin, com mais de uma / antes da sua versão, ou que contenha um host de registo:
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 (a referência de plugin não é uma entidade Plugin: tem de ser um URI de entidade Plugin com âmbito de tipo de plugin (opcionalmente com versão); uma referência a um ficheiro Wasm simples ou uma referência de artefacto não nomeia nenhuma entidade Plugin)
Como corrigir: escreva a referência como a identidade da entidade Plugin com âmbito de tipo de socket, opcionalmente com a sua versão — <pluginType>/<name> ou <pluginType>/<name>:<version>. Se estava a apontar diretamente para um ficheiro ou um artefacto, publique ou escreva uma entidade Plugin para ele e referencie-a em vez disso — é na entidade que residem as declarações que o carregamento verifica, pelo que não existe forma equivalente que a dispense. Se a mensagem indicar que a referência é um URI de entidade Plugin, a sua forma está correta e o que falta é a entidade: coloque a entidade Plugin num diretório de catálogo que o espaço de trabalho enumere, com o seu .wasm compilado ao lado, ou publique o plugin num registo que o espaço de trabalho leia e execute aggrega pull, que o obtém para a cache de conteúdo — e verifique se a versão que indica existe.
A cached signature bundle does not match the digest recorded for it (Um bundle de assinatura em cache não corresponde ao digest registado para ele)
Um artefacto cuja assinatura foi verificada quando foi obtido transporta esse facto na sua entrada do ficheiro de bloqueio — ou, para um plugin anexado a um papel de veredicto, na sua entrada em plugins-trust.yaml — como um digest registado do material de assinatura, guardado em cache junto ao artefacto. Antes de qualquer renderização, a compilação volta a ler esse material em cache para cada entrada que lê e que registe um — uma entidade de catálogo de qualquer tipo, uma biblioteca, um plugin — e recalcula o hash, que tem de ser o registado. Um plugin que o ficheiro de bloqueio fixa, e um plugin anexado a um papel de veredicto, tem o seu material verificado novamente quando os seus bytes são carregados, e é isso que chega aos comandos que carregam um plugin fora de uma compilação — entre eles aggrega lint --release e aggrega validate --release. Um bundle em falta, ilegível ou cujo hash é outro significa que o material revisto não é o que está agora no disco, e a execução é interrompida em vez de usar um artefacto cuja evidência de assinatura mudou à revelia do registo.
A nova verificação é uma comparação de hashes e nada mais. Não volta a verificar nenhuma assinatura, não contacta nenhuma rede e não consulta nenhum material de confiança, pelo que se mantém numa compilação sem qualquer acesso à rede — e é isso que permite que um artefacto verificado uma vez continue verificado nas compilações offline posteriores.
O pull seguinte repara-o. Um pull submete à mesma verificação cada entrada que a cache de conteúdo serviu e, onde a verificação recusa uma entrada, volta a perguntar ao registo do artefacto pela assinatura — seja qual for o requisito de assinatura, através da mesma verificação que recebe um artefacto que obtém —, regista na entrada o que essa verificação confirma e guarda em cache o bundle que ela indica, reescrevendo uma cópia em cache que já não corresponde ao seu digest. Um plugin anexado a um papel de veredicto é verificado novamente em cada pull, seja o que for que a sua entrada registe, e o seu bundle é guardado em cache da mesma forma. Por isso, a mensagem de uma entrada que a cache de conteúdo serviu indica esse pull. Uma entrada lida de um diretório de catálogo, da cópia dentro do binário do compilador ou de junto da Release nunca é consultada num registo, pelo que um pull deixa como está uma assinatura registada nela, e a sua mensagem não indica nenhum pull.
Mensagens emitidas, que indicam o artefacto, o ficheiro em cache e — para uma entrada que a cache de conteúdo serviu — o pull que a repara, o ficheiro em que regista a assinatura e a Release que obtém. Da verificação da compilação, ilegível ou 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: o bundle de assinatura em cache está ilegível: o bundle de assinatura em cache não corresponde ao seu digest registado. correção: execute o pull para verificar novamente a assinatura do artefacto no seu registo, registá-la no ficheiro e guardar em cache o bundle que ela indica)
e divergente:
artifact "<reference>": cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (artefacto: o bundle de assinatura em cache tem um digest diferente do registado: o bundle de assinatura em cache não corresponde ao seu digest registado. correção: execute o pull para verificar novamente a assinatura do artefacto no seu registo, registá-la no ficheiro e guardar em cache o bundle que ela indica)
e, quando os bytes de um plugin são carregados da cache de conteúdo, indicando também de onde vieram:
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 resolvido a partir da sua origem: o bundle de assinatura em cache está ilegível: o bundle de assinatura em cache não corresponde ao seu digest registado. correção: execute o pull para verificar novamente a assinatura do artefacto no seu registo, registá-la no ficheiro e guardar em cache o bundle que ela indica)
plugin "<reference>" resolved from <source>: cached signature bundle <path> has digest <actual>, recorded digest is <recorded>: cached signature bundle does not match its recorded digest. remediation: run aggrega pull --release <release> to verify the artifact’s signature at its registry again, record it in <file> and cache the bundle it names (plugin resolvido a partir da sua origem: o bundle de assinatura em cache tem um digest diferente do registado: o bundle de assinatura em cache não corresponde ao seu digest registado. correção: execute o pull para verificar novamente a assinatura do artefacto no seu registo, registá-la no ficheiro e guardar em cache o bundle que ela indica)
<file> é o ficheiro de bloqueio da Release, ou plugins-trust.yaml no diretório da Release. Para uma entrada sobre a qual nenhum pull pergunta, a mensagem termina antes de remediation:.
Um pull que não tem nenhum registo a consultar é interrompido em vez disso. Uma entidade de catálogo ou uma biblioteca é nomeada sem registo e é associada a um através do default_registry do espaço de trabalho. Onde o espaço de trabalho não nomeia nenhum — nomeava quando a assinatura foi registada, e já não nomeia —, nenhum registo está configurado para ser consultado novamente sobre a entrada, pelo que o pull é interrompido com esta condição em vez de escrever um ficheiro de bloqueio que a compilação seguinte recusa, e deixa o ficheiro de bloqueio como estava. A sua mensagem contém, depois do passo que o pull estava a executar:
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: regista uma assinatura que uma compilação não aceita, e nenhum registo está configurado para ser consultado novamente sobre ela: o bundle de assinatura em cache está ilegível: o bundle de assinatura em cache não corresponde ao seu digest registado)
Como corrigir: nada nos seus ficheiros de entidade causa isto — a cache é da compilação, não sua. Execute aggrega pull --release <release>, o comando que a mensagem indica: verifica novamente a assinatura do artefacto e escreve em conjunto a assinatura e o seu bundle, o que repara um bundle removido ou alterado desde o pull que o guardou em cache. No modo offline esse pull é interrompido — com a recusa offline, porque reparar significa consultar o registo, ou, para um plugin anexado a um papel de veredicto, antes disso, indicando o .wasm do plugin como um que não conseguiu resolver, porque um pull resolve esse .wasm a partir do registo do plugin; permitir a rede para essa única execução repara-o. Onde o pull é interrompido a dizer que nenhum registo está configurado para ser consultado sobre a entrada, defina default_registry como o registo do qual o artefacto foi obtido por pull, e faça o pull novamente. Onde o espaço de trabalho ignora a verificação de assinatura para o artefacto, o pull, em vez disso, não regista nenhuma assinatura na entrada, o que a compilação admite com essa mesma definição. Onde a assinatura que o registo serve não é verificada, o pull é interrompido com a recusa da própria verificação: a assinatura registada e o material que o publicador serve divergem de facto, e essa é uma questão para quem publica o artefacto. Para uma entrada cuja mensagem não indica nenhum pull — uma lida de um diretório de catálogo, da cópia dentro do binário do compilador ou de junto da Release —, remova a signature da sua entrada: uma entrada assim nunca é sujeita a um requisito de assinatura, pelo que a compilação prossegue.
A recorded signature was made for a different artifact (Uma assinatura registada foi feita para um artefacto diferente)
Uma assinatura indica para que artefacto foi feita. Quando um pull verifica a assinatura de um artefacto, regista o facto na entrada do ficheiro de bloqueio do artefacto — ou, para um plugin anexado a um papel de veredicto, na sua entrada em plugins-trust.yaml — e guarda em cache a assinatura que verificou. Antes de qualquer renderização, a compilação lê, na assinatura em cache de cada entrada que a cache de conteúdo serviu, para que artefacto foi feita, e esse tem de ser o artefacto que a própria compilação leu para a entrada: aquele cujo manifesto é mantido junto aos seus bytes na cache de conteúdo, nunca algo que a entrada registe. Uma assinatura feita para um artefacto diferente interrompe a compilação. É esse o aspeto de uma signature copiada de uma entrada para outra: a assinatura em cache que indica está intacta — ainda corresponde ao digest registado para ela — e foi feita para o artefacto da outra entrada.
Não depende de um requisito de assinatura. Uma assinatura registada é confrontada com aquilo que afirma, seja ou não exigida uma assinatura, tal como acontece com a verificação de que a assinatura em cache corresponde ao seu digest registado.
Um plugin é verificado da mesma forma onde quer que seja carregado. Um plugin que o ficheiro de bloqueio fixa, e um plugin anexado a um papel de veredicto, tem a sua assinatura registada confrontada com o artefacto do qual os seus bytes foram lidos quando esses bytes são carregados da cache de conteúdo, o que chega aos comandos que carregam um plugin fora de uma compilação — entre eles aggrega lint --release e aggrega validate --release, e as mesmas operações acedidas através de aggrega serve e aggrega mcp.
O que a verificação lê e o que não consegue distinguir. Lê a assinatura em cache e o manifesto junto ao artefacto, e compara hashes: não verifica nenhuma assinatura, não contacta nenhuma rede e não consulta nenhum material de confiança, pelo que se mantém numa compilação sem qualquer acesso à rede. Lê para que artefacto uma assinatura foi feita nas duas formas que um pull aceita — uma assinatura feita sobre o próprio artefacto, que é o que os signatários da própria cadeia de ferramentas produzem, e uma declaração assinada que indica o artefacto —, pelo que uma assinatura copiada de uma entrada para outra é recusada em qualquer das duas formas. É a mesma leitura que um pull aplica a cada assinatura que aceita: um pull recusa uma assinatura que é verificada, mas que a leitura não encontra feita para o artefacto, ou da qual não consegue de todo ler o artefacto, pelo que nenhuma assinatura que um pull regista é uma que a verificação não consiga ler. Uma entrada lida de um diretório de catálogo, da cópia dentro do binário do compilador ou de junto da Release vem sem manifesto, pelo que a sua assinatura registada é confrontada apenas com o seu digest registado; o mesmo acontece com uma assinatura colocada à mão na cache numa forma que não é nenhuma dessas duas. E como nenhuma assinatura é verificada, uma assinatura escrita à mão na cache, emitida para o próprio artefacto da entrada, não se distingue de uma que um pull verificou.
O pull seguinte repara-o. Um pull submete à mesma verificação cada entrada que a cache de conteúdo serviu e, onde a verificação recusa uma entrada, volta a perguntar ao registo do artefacto pela assinatura — seja qual for o requisito de assinatura — e regista na entrada o que essa verificação confirma em lugar da assinatura copiada. Um plugin anexado a um papel de veredicto é verificado novamente em cada pull, seja o que for que a sua entrada registe. Apenas numa entrada que a cache de conteúdo serviu se verifica para que artefacto a sua assinatura foi feita, pelo que cada recusa desta condição por uma compilação ou por um carregamento de plugin indica esse pull.
Mensagens emitidas, que indicam a entrada, o ficheiro que regista a assinatura, a assinatura em cache, o manifesto que a compilação leu para a entrada e o pull que a repara. Da verificação da compilação:
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: a assinatura registada foi feita para um artefacto diferente, com o ficheiro que a regista, o bundle de assinatura em cache e o manifesto do artefacto lido. correção: execute o pull para verificar novamente a assinatura do artefacto no seu registo, registá-la no ficheiro e guardar em cache o bundle que ela indica)
e, quando os bytes de um plugin são carregados, indicando também de onde vieram:
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 resolvido a partir da sua origem: signing: a assinatura registada foi feita para um artefacto diferente, com o ficheiro que a regista, o bundle de assinatura em cache e o manifesto do artefacto lido. correção: execute o pull para verificar novamente a assinatura do artefacto no seu registo, registá-la no ficheiro e guardar em cache o bundle que ela indica)
<file> é o ficheiro de bloqueio da Release, ou plugins-trust.yaml no diretório da Release.
Um pull que não tem nenhum registo a consultar é interrompido em vez disso, tal como acontece com um bundle de assinatura em cache que já não corresponde ao seu digest: onde uma entidade de catálogo ou uma biblioteca contém uma assinatura copiada e o espaço de trabalho já não nomeia um default_registry ao qual associá-la, o pull é interrompido com esta condição e deixa o ficheiro de bloqueio como estava. A sua mensagem contém, depois do passo que o pull estava a executar:
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: regista uma assinatura que uma compilação não aceita, e nenhum registo está configurado para ser consultado novamente sobre ela: signing: a assinatura registada foi feita para um artefacto diferente, com o bundle de assinatura em cache e o manifesto do artefacto lido)
Como corrigir: nada nos seus ficheiros de entidade causa isto — a assinatura que a entrada regista pertence a outro artefacto. Execute aggrega pull --release <release>, o comando que a mensagem indica: verifica a própria assinatura da entrada no seu registo e regista-a em lugar da copiada, tanto para uma entrada do ficheiro de bloqueio como para um plugin anexado a um papel de veredicto. Restaurar a partir do controlo de versões a própria assinatura registada da entrada, onde o ficheiro foi alvo de commit, também funciona. No modo offline o pull é interrompido — com a recusa offline, porque reparar significa consultar o registo, ou, para um plugin anexado a um papel de veredicto, antes disso, indicando o .wasm do plugin como um que não conseguiu resolver, porque um pull resolve esse .wasm a partir do registo do plugin; permitir a rede para essa única execução repara-o. Onde o pull é interrompido a dizer que nenhum registo está configurado para ser consultado sobre a entrada, defina default_registry como o registo do qual o artefacto foi obtido por pull, e faça o pull novamente. Onde o espaço de trabalho ignora a verificação de assinatura para o artefacto, o pull, em vez disso, não regista nenhuma assinatura na entrada, o que a compilação admite com essa mesma definição.
No verified signature is recorded for an artifact that requires one (Nenhuma assinatura verificada está registada para um artefacto que exige uma)
Um pull que obtém um artefacto de um registo verifica a sua assinatura face à política de confiança desse registo e regista o facto verificado na entrada do ficheiro de bloqueio do artefacto. Uma compilação não alcança nenhum registo, pelo que lê o facto registado em vez de verificar de novo — e, antes de qualquer renderização, submete cada entrada que lê ao requisito que o pull aplicou quando obteve o artefacto. Uma entrada servida pela cache de conteúdo, para um artefacto para o qual é exigida uma assinatura, que não regista nenhuma assinatura verificada interrompe a compilação: nada do que a compilação detém indica que o artefacto a partir do qual está prestes a renderizar tenha alguma vez sido verificado.
O requisito é o do pull, definição a definição. É exigida uma assinatura onde a política de assinatura de todo o espaço de trabalho abrange o tipo do artefacto, ou onde a própria entrada do registo em .aggrega-config.yaml — ou, para hub.aggrega.ai sem entrada própria, a política integrada do hub oficial — exige uma; um artefacto cujo tipo não pôde ser determinado conta como exigido sob uma política ativa. O que permite a um pull admitir um artefacto sem assinatura permite também à compilação admitir a sua entrada: skip_signature_verification no nível superior, a mesma opção na própria entrada do registo, exceto para um tipo que a política de todo o espaço de trabalho exige, e um registo marcado como advisory.
A origem de uma entrada lê-se a partir da compilação, nunca do ficheiro de bloqueio. Toda a entrada servida pela cache de conteúdo é submetida ao requisito, independentemente do que mais a entrada registe, pelo que remover o digest do manifesto de uma entrada juntamente com a sua assinatura não a isenta. Uma entrada lida de um diretório de catálogo, da cópia incorporada no binário do compilador ou de junto da Release nunca lhe é submetida, porque não existe nenhuma assinatura de registo para bytes que não vieram de um. As entradas de todas as secções são verificadas da mesma forma — entidades de catálogo, bibliotecas e artefactos de plugin — e cada entrada que a verificação recusa é nomeada na mesma execução.
Um plugin anexado num papel de veredicto é submetido à mesma verificação, através de plugins-trust.yaml. Um anexo plugins.governance num papel ir-verdict ou render-verdict, e todo o anexo plugins.linter, não molda nenhum byte renderizado, pelo que não tem entrada no ficheiro de bloqueio; o ficheiro de confiança ao lado do ficheiro de bloqueio contém, em vez disso, a sua assinatura verificada. Cada plugin deste tipo que a compilação lê da cache de conteúdo é submetido ao mesmo requisito, através das mesmas definições: uma entrada nesse ficheiro de confiança que não regista nenhuma assinatura interrompe a compilação, e o mesmo sucede se não existir nenhuma entrada para o plugin — eliminar o ficheiro de confiança não o isenta. Um plugin servido a partir de um diretório de catálogo ou da cópia incorporada no binário do compilador não lhe é submetido. O requisito aplica-se a um plugin deste tipo onde quer que seja carregado para uma Release, não apenas numa compilação: aggrega lint --release e aggrega validate --release, e as mesmas operações alcançadas através de aggrega serve e aggrega mcp, falham nesta condição quando o carregam.
Mensagens emitidas, que nomeiam a entrada, o ficheiro que não regista nenhuma assinatura para ela, as definições que exigem a sua assinatura e o comando que a regista nesse ficheiro. Para uma entrada do ficheiro de bloqueio, nomeando o ficheiro de bloqueio:
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: nenhuma assinatura verificada está registada para um artefacto que exige uma: o ficheiro de bloqueio não regista nenhuma assinatura para ele, exigida pelas definições indicadas. correção: executar o pull para verificar a assinatura do artefacto no seu registo e registá-la no ficheiro de bloqueio)
e para um plugin anexado num papel de veredicto, nomeando o seu ficheiro de confiança:
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: nenhuma assinatura verificada está registada para um artefacto que exige uma: o ficheiro de confiança não regista nenhuma assinatura para o plugin, exigida pelas definições indicadas. correção: executar o pull para verificar a assinatura do plugin no seu registo e registá-la no ficheiro de confiança)
Ambos os ficheiros são nomeados pelo seu caminho junto da Release dada ao comando: <lockfile-path> é o ficheiro de bloqueio da Release, e <record-path> é plugins-trust.yaml no diretório da Release.
As definições são nomeadas nas próprias palavras do ficheiro de configuração: `signing.required` at the top level of the workspace configuration, `signing.required` on the `registries` entry for "<host>" ou the official hub's built-in signature requirement for "hub.aggrega.ai", unidas onde se aplica mais de uma.
Como corrigir: executar o pull que a mensagem nomeia. Para uma entrada servida pela cache de conteúdo que não regista nenhuma assinatura onde uma é exigida, o pull pede ao registo do artefacto a sua assinatura, pelo digest do manifesto que a entrada regista, exatamente como faz para um artefacto que obtém, e regista a assinatura verificada na entrada — para que a compilação seguinte a leia. Sobre um plugin anexado num papel de veredicto a pergunta é feita em cada pull de qualquer forma, e o pull regista o que verificou na entrada do plugin em plugins-trust.yaml, criando a entrada onde não existir nenhuma. Um registo que não anexa nenhuma assinatura, ou uma assinatura que a configuração de confiança não aceita, interrompe antes esse pull, nomeando o artefacto, e essa é uma questão para quem o publica. No modo offline o pull não pode perguntar: sobre uma entrada do ficheiro de bloqueio recusa, indicando como permitir a rede para uma execução, e sobre um plugin anexado num papel de veredicto interrompe-se antes de perguntar, nomeando o .wasm do plugin como um que não conseguiu resolver, porque um pull resolve esse .wasm a partir do registo do plugin. Repor a assinatura registada da entrada a partir do controlo de versões resolve-o sem a rede, onde a cache ainda contém o material de assinatura que essa entrada nomeia. Onde o artefacto não se destina a ser assinado, o que há a alterar é o requisito, e a mensagem nomeia qual definição é — mas relaxá-lo significa que os artefactos desse registo deixam de ser verificados também num pull, pelo que é preferível restringir os tipos da política de todo o espaço de trabalho a desativar um requisito.
A recorded signature is not the one a pull would record (Uma assinatura registada não é a que um pull registaria)
aggrega pull --verify comunica se executar aggrega pull agora alteraria os ficheiros que um pull grava, e a assinatura que um pull verificou para um artefacto faz parte do que escreve: a signature numa entrada do ficheiro de bloqueio, e numa entrada de plugins-trust.yaml para um plugin anexado num papel de veredicto. Esta condição é o que uma verificação comunica para cada assinatura registada que um pull simples escreveria de forma diferente — uma que registaria onde nenhuma está registada, uma que substituiria ou uma que apagaria. A verificação não escreve nenhum dos dois ficheiros e nomeia cada uma dessas entradas, em qualquer dos ficheiros, na mesma execução.
Duas entradas do ficheiro de bloqueio são comunicadas sem perguntar a um registo, porque um pull as reescreve seja qual for a resposta do registo, pelo que são comunicadas também no modo offline: uma entrada servida pela cache de conteúdo que não regista nenhuma assinatura onde a configuração de confiança exige uma — o pull regista a assinatura do artefacto, ou interrompe-se onde não consegue estabelecer uma — e uma entrada cuja assinatura registada foi feita para outro artefacto, que o pull substitui pela própria do artefacto.
Sobre qualquer outra entrada que um pull voltaria a consultar é feita a pergunta, porque só a resposta do registo diz se o pull a alteraria: uma entrada cujos bytes a verificação obteve porque a cache de conteúdo não os continha, e uma entrada cujo bundle de assinatura em cache foi removido, está ilegível ou foi alterado. A verificação pergunta ao registo como o pull faria, comunica a entrada onde a resposta regista, substitui ou apaga a sua assinatura, e guarda em cache o bundle que verificou tal como um pull o guarda. No modo offline não se pergunta sobre essa entrada nem ela é comunicada: a verificação imprime uma linha que a nomeia e diz que a sua assinatura não foi verificada.
Para o ficheiro de confiança de plugins, cada pull verifica a assinatura de cada plugin anexado num papel de veredicto no seu registo, e o mesmo faz uma verificação: é comunicada uma entrada cuja assinatura essa verificação registaria, substituiria ou apagaria, e também um plugin para o qual o ficheiro de confiança não contém nenhuma entrada onde uma compilação o recusa por não registar nenhuma assinatura, porque um pull escreve uma entrada com a sua assinatura e a compilação recusa o plugin até lá. Qualquer outro plugin que o ficheiro de confiança ainda não contém é uma primeira aparição e não é comunicado. No modo offline uma verificação não pergunta a nenhum registo sobre estes plugins: lê cada um da cache de conteúdo, como uma compilação o lê, e verifica a sua identidade e as suas funções host como faz uma verificação ligada. Comunica sem perguntar um plugin que uma compilação recusa por não registar nenhuma assinatura — a sua entrada não regista nenhuma, ou o ficheiro de confiança não contém nenhuma entrada para ele — e um que uma compilação recusa porque a assinatura que a sua entrada regista foi feita para outro artefacto, porque um pull reescreve essa entrada seja qual for a resposta do registo; imprime uma linha que nomeia cada outra entrada e diz que a sua assinatura não foi verificada.
Os marcadores de descontinuação não são comparados. Um marcador anexado a um artefacto depois do pull é o estado do registo e muda sem que nada no espaço de trabalho mude, pelo que uma verificação que falhasse por causa dele faria falhar um controlo sobre ficheiros em que ninguém mexeu — a razão pela qual um marcador registado avisa uma compilação em vez de a interromper.
Mensagens emitidas, uma por entrada, que nomeiam a entrada, o ficheiro e o que regista, o que um pull registaria em vez disso, e o pull que atualiza o ficheiro. Onde a resposta do registo, ou a própria verificação do ficheiro de confiança, fornece a assinatura que um pull registaria:
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: uma assinatura registada não é a que um pull registaria: o ficheiro regista uma assinatura, um pull registaria outra. correção: executar o pull para atualizar o ficheiro)
para uma entrada que não regista nenhuma assinatura onde uma é exigida — uma entrada do ficheiro de bloqueio ou, no modo offline, uma entrada do ficheiro de confiança 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: uma assinatura registada não é a que um pull registaria: o ficheiro não regista nenhuma assinatura, um pull pediria ao seu registo a assinatura que um requisito exige e registá-la-ia. correção: executar o pull para atualizar o ficheiro)
para uma entrada cuja assinatura registada foi feita para outro artefacto — uma entrada do ficheiro de bloqueio ou, no modo offline, uma entrada do ficheiro de confiança 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: uma assinatura registada não é a que um pull registaria: o ficheiro regista uma assinatura feita para outro artefacto, um pull pediria ao seu registo a própria assinatura deste artefacto e registá-la-ia. correção: executar o pull para atualizar o ficheiro)
e para um plugin para o qual o ficheiro de confiança não contém nenhuma entrada, onde uma compilação o recusa por não registar nenhuma assinatura — a segunda forma no modo offline, em que a verificação não pergunta a nenhum registo:
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: uma assinatura registada não é a que um pull registaria: o ficheiro de confiança não contém nenhuma entrada para o plugin e é exigida uma assinatura para ele, um pull registaria uma assinatura. correção: executar o pull para atualizar o ficheiro de confiança)
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: uma assinatura registada não é a que um pull registaria: o ficheiro de confiança não contém nenhuma entrada para o plugin e é exigida uma assinatura para ele, um pull pediria ao seu registo a assinatura que um requisito exige e registá-la-ia. correção: executar o pull para atualizar o ficheiro de confiança)
<signature> indica uma assinatura pelo seu modo, pelo seu signatário e pelo digest do seu bundle — a keyed signature by keyed:sha256:<fingerprint> with bundle digest sha256:<digest>, com issued by <issuer> depois do signatário para uma assinatura sem chave — ou é no signature. <file> é o ficheiro de bloqueio da Release, <lockfile-path>, ou plugins-trust.yaml no diretório da Release, <record-path>.
Como corrigir: executar o pull que a mensagem nomeia. Escreve no ficheiro nomeado a assinatura que a mensagem diz que escreveria, e guarda o seu bundle em cache, pelo que a verificação seguinte passa. Onde a mensagem diz que um pull perguntaria ao registo, o pull regista o que o registo verifica — e, em vez disso, interrompe-se, nomeando o artefacto, onde o registo anexa uma assinatura que a configuração de confiança não aceita, ou nenhuma onde uma é exigida, o que é uma questão para quem o publica. No modo offline esse pull interrompe-se: sobre uma entrada do ficheiro de bloqueio com a recusa offline, porque tem de perguntar ao registo, e sobre um plugin anexado num papel de veredicto antes disso, nomeando o .wasm do plugin como um que não conseguiu resolver, porque um pull resolve esse .wasm a partir do registo do plugin. Permitir a rede para essa única execução atualiza o ficheiro. Onde a mensagem diz que um pull não registaria nenhuma assinatura, o registo já não anexa nenhuma e nada a exige: o pull apaga a assinatura da entrada, o que uma compilação admite sob as mesmas definições — se não esperava que o registo deixasse de assinar o artefacto, essa também é uma questão para o seu publicador.
A plugin’s .wasm is not on this machine (O ficheiro Wasm de um plugin não está nesta máquina)
O .wasm de um plugin é lido de um de quatro locais, por esta ordem: os plugins integrados no binário do compilador, um ficheiro ao lado da entidade Plugin do plugin num diretório de catálogo, um caminho explícito do sistema de ficheiros que a referência indica e a cache de conteúdo do espaço de trabalho que aggrega pull preenche. Resolver um plugin só lê o que já está na máquina e não obtém nada, pelo que esta condição comunica que nenhum dos quatro contém os bytes — não que uma transferência falhou. Um plugin é a exceção: um importador core de que uma importação precisa. O seu módulo é lido apenas do binário ou da cache de conteúdo, nunca de ao lado de uma entidade de catálogo, e, onde nenhum dos dois o contém, a importação obtém-no uma vez do registo predefinido do espaço de trabalho; a condição comunica então também que a obtenção não foi possível — o espaço de trabalho está offline, o seu registo não pôde ser contactado ou não contém o módulo, ou o espaço de trabalho não indica nenhum registo predefinido. Um módulo que foi obtido e não passa na verificação é recusado sob a sua própria condição, uma divergência de digest ou uma recusa de assinatura, e nada é guardado.
O ficheiro ao lado da entidade é nomeado a partir do tipo de plugin e do nome da entidade, e a recusa do pull mais abaixo indica o nome: para pipeline-step/patch é pipeline-step--patch.wasm, no diretório onde se encontra o documento da entidade.
Uma entidade Plugin escrita num dos seus diretórios de catálogo é recusada quando o pull a resolve. Um pull nunca obtém o .wasm de uma entidade dessas: procura nos quatro locais acima, exatamente onde uma compilação procura. Um passo de pipeline, um fornecedor ou um plugin anexado a um papel de veredicto não é fixado de todo, e uma compilação lê a sua entidade do diretório de catálogo de cada vez. Um plugin anexado a um papel de transformação é fixado, porque os seus bytes moldam a saída renderizada: o pull regista a sua entidade e o digest de conteúdo do .wasm que lá encontrou, e uma compilação recusa um .wasm que já não corresponda. Assim, um pull que não encontra o artefacto em nenhum dos quatro locais interrompe-se aí, antes de escrever o ficheiro de bloqueio ou qualquer entity.lock, em vez de deixar uma compilação falhar mais tarde, no passo que carrega o plugin. Um .wasm que o binário traz, ou um que já está na cache de conteúdo, satisfaz o pull exatamente como satisfaz a compilação, pelo que uma entidade para um plugin distribuído dentro do compilador não precisa de nenhum ficheiro ao lado.
Mensagens emitidas. A recusa do pull, que aponta para o diretório onde esperava o ficheiro, com a resolução sobre a qual perguntou por baixo:
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 não encontrado nesta máquina: a entidade Plugin está escrita num diretório de catálogo e o ficheiro indicado era esperado no diretório indicado. Colocar o .wasm compilado ao lado da entidade com esse nome, ou publicar o plugin e referenciar a entidade Plugin publicada em vez da que está no diretório de catálogo)
um plugin que uma compilação ou uma importação carrega sem que nenhuma origem contenha os seus bytes — e um plugin anexado a um papel de veredicto que aggrega pull --verify no modo offline lê da cache de conteúdo, como faz uma compilação. Onde a entidade Plugin do plugin se encontra numa pasta de catálogo, indicando a versão em que está e para onde vai o seu 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 (o plugin, na versão indicada, não está nesta máquina; colocar o seu módulo, com o nome indicado, ao lado da sua entidade Plugin no diretório indicado: artefacto de plugin não encontrado nesta máquina)
e, caso contrário, indicando cada local onde o módulo foi procurado:
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 (o plugin não está nesta máquina: o binário não traz o seu módulo, nenhuma pasta de catálogo contém a sua entidade Plugin e a cache de conteúdo para onde um pull obtém não o contém: artefacto de plugin não encontrado nesta máquina)
Um lint, que procura apenas no binário, indica só o primeiro desses locais.
e o mesmo para uma referência escrita como uma localização de registo:
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 não resolúvel: um URI de plugin OCI exige um pull prévio, para que os seus bytes fiquem em cache, ou um caminho local explícito; a resolução de plugins não obtém nada de um registo: artefacto de plugin não encontrado nesta máquina)
um importador core que uma importação não conseguiu nem ler nem obter, indicando o importador, a sua versão e o motivo — aqui, o espaço de trabalho estar offline — e depois o que coloca o seu módulo na 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 (o importador core, na versão indicada, não está nesta máquina, e o espaço de trabalho está offline, pelo que o seu registo não é consultado; executar a importação uma vez com a rede disponível, o que o obtém do registo predefinido do espaço de trabalho, o verifica e o guarda na cache de conteúdo para todas as importações posteriores, ou colocar o seu módulo, com o nome indicado, ao lado de uma entidade Plugin desse importador nessa versão numa pasta de catálogo: artefacto de plugin não encontrado nesta máquina)
Os outros motivos dizem its registry <host> could not be reached (<cause>), its registry <host> holds no <location>:<version> e the workspace names no default registry to fetch it from; os dois últimos indicam apenas a segunda solução, porque uma execução com a rede disponível não os alteraria.
Como corrigir: onde a entidade é escrita pelo próprio utilizador, compilar o plugin e colocar o seu .wasm ao lado da entidade com o nome que a mensagem indica — ou publicar o plugin com aggrega push e referenciar a entidade publicada em vez da cópia do catálogo, uma vez que nem um pull nem uma compilação obtêm o .wasm de uma entidade do catálogo do utilizador. Onde o plugin é consumido a partir de um registo, executar aggrega pull para a Release, que o coloca em cache. Onde se esperava que o próprio compilador trouxesse o plugin, verificar se o binário em execução o traz: aggrega plugin list indica os plugins integrados. Onde se trata de um importador core, executar a importação uma vez num local onde o espaço de trabalho possa contactar o seu registo predefinido — essa execução obtém-no, verifica-o e coloca-o em cache, e todas as importações posteriores são offline — ou, onde esse registo não o contém, colocar o seu módulo ao lado de uma entidade Plugin desse importador nessa versão numa pasta de catálogo, com o nome que a mensagem indica; essa entidade passa então a ser executada no lugar do importador core.
A plugin recorded as a trusted gate is no longer attached (Um plugin registado como controlo fidedigno já não está anexado)
Um plugin que devolve um veredicto de aceitação ou rejeição sobre uma compilação é registado assim que é resolvido, para que o espaço de trabalho guarde um ficheiro de confiança dos controlos que foram revistos. Esta condição é o que comunica um controlo registado que já nada anexa. A razão pela qual interrompe a compilação em vez de a deixar passar silenciosamente é que, de outro modo, a sua saída seria indistinguível de uma saída que o controlo aprovou: uma compilação com o controlo silenciosamente ausente e uma compilação que o controlo deixou passar produzem os mesmos ficheiros, e ninguém que revisse o resultado conseguiria dizer qual das duas tem em mãos.
É uma questão diferente da de um plugin cujos bytes mudaram. Essa recusa executar um plugin que não é o revisto — uma questão de identidade. Esta recusa compilar com um controlo revisto totalmente em falta — uma questão de presença. As soluções diferem em conformidade: restaurar o artefacto, por oposição a restaurar o anexo.
O que estabelece e o que não estabelece. Manter a configuração fiel ao ficheiro de confiança estabelece que cada controlo registado continua anexado e que o artefacto de cada um é o registado. Não estabelece nada sobre se um controlo anexado devolve de facto um veredicto: um anexo cuja função de entrada indica uma exportação declarada que não devolve nenhum veredicto é executado, não comunica nada e deixa passar a compilação, e nenhuma comparação com o ficheiro de confiança dá por isso — o plugin que foi executado é exatamente o registado e simplesmente não executou nada. Dois casos vizinhos interrompem de facto a compilação, e são indicados para que este limite não seja lido como mais amplo do que é: uma função de entrada que indica uma exportação que o plugin não declara é recusada quando o plugin é carregado, e uma saída que contém uma chave que a estrutura do veredicto não declara é recusada em vez de ser lida como uma lista de veredictos vazia.
Mensagem emitida, que indica o ficheiro de confiança, os controlos removidos e as duas soluções:
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 (um plugin registado como fidedigno para um veredicto de aceitação ou rejeição já não está anexado a nenhum papel de veredicto: o ficheiro de confiança regista o plugin como fidedigno, mas nenhum anexo de veredicto na configuração do espaço de trabalho o indica; um controlo que foi revisto e agora está ausente deixa uma saída indistinguível de uma saída que esse controlo aprovou. Anexar novamente o plugin na secção de governação dos plugins a um papel de veredicto de IR ou de veredicto de renderização, ou na secção do linter; ou, se devia sair, executar a atualização direcionada para o retirar do ficheiro de confiança — um pull comum deixa o ficheiro de confiança como está, pelo que só uma atualização explícita retira uma entrada)
Onde foi removido mais de um controlo, são indicados juntos num único comando de atualização em vez de um comando cada: uma atualização direcionada aceita vários alvos e deixa intacta cada fixação que não indicou, pelo que indicá-los juntos é simultaneamente mais curto e mais restrito do que a atualização completa de que a alternativa precisaria.
Como corrigir: a mensagem oferece duas soluções porque só o utilizador sabe qual se aplica. Se o controlo foi removido por engano, anexar novamente o plugin em plugins.governance a um papel de veredicto, ou em plugins.linter. Se devia sair, dizê-lo explicitamente com a atualização direcionada que a mensagem descreve, que é o que retira a sua entrada. Não editar nem eliminar o ficheiro de confiança para resolver esta condição — é o ficheiro, confirmado no repositório, do que foi revisto, e um pull comum deixa-o deliberadamente como está, porque adotar uma remoção silenciosamente é exatamente o que esta recusa existe para impedir.
A gate recorded as trusted resolves to a different identity (Um controlo registado como fidedigno resolve-se para uma identidade diferente)
Um plugin que devolve um veredicto de aceitação ou rejeição sobre uma compilação é registado assim que é resolvido, juntamente com a versão e o digest do artefacto para os quais foi resolvido. Esta condição é o que comunica uma resolução posterior quando chega a uma versão diferente ou a bytes diferentes para um controlo que o ficheiro de confiança já contém, e a execução nunca pediu que essa identidade fosse adotada.
Uma única condição abrange tanto uma versão que mudou como bytes que mudaram, porque o ficheiro de confiança é endereçado pela identidade do plugin e contém a versão e o digest como campos de uma única entrada: comparar uma resolução com ele é uma única comparação com um único resultado. Uma republicação que não alterou nenhum byte e um novo push na mesma versão são o mesmo acontecimento para quem revê — a identidade já não é a que foi revista.
É uma questão diferente da de um controlo registado que já nada anexa, que é uma questão de presença e não de identidade. É também diferente da de um plugin cujos bytes em cache não concordam com o digest registado: essa recusa executar um plugin que não é o revisto, e a sua solução é restaurar ou voltar a registar o artefacto, enquanto esta recusa adotar uma nova identidade sem que isso seja pedido, e a sua solução é indicar o plugin numa atualização. Duas soluções, duas condições.
Pedir a nova identidade é o que um pull já oferece, e há duas formas de a pedir. Uma atualização completa resolve tudo de novo, e uma atualização direcionada resolve de novo os plugins que indica; qualquer uma delas é lida como um pedido da nova identidade, e o ficheiro de confiança é atualizado. Qualquer outro pull mantém a identidade registada e interrompe-se, que é o objetivo de a registar — um ficheiro de confiança que adotasse o que quer que fosse resolvido a seguir seguiria a resolução em vez de a governar. Uma primeira aparição não é uma divergência: uma identidade que o ficheiro de confiança ainda não contém é simplesmente preenchida.
A comparação também é executada num pull que apenas verifica, que não escreve nem o ficheiro de confiança nem o ficheiro de bloqueio. Uma verificação que ignorasse o ficheiro de confiança enquanto verifica o ficheiro de bloqueio ao lado dele comunicaria uma concordância que nunca procurou.
Mensagem emitida, que indica o plugin, as duas identidades e as duas soluções:
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: o ficheiro de confiança regista para ele uma versão e um digest como fidedignos, mas esta resolução comunica outra versão e outro digest; rever o que mudou e adotá-lo com a atualização direcionada, ou restaurar a identidade registada: a identidade do plugin registada como fidedigna já não corresponde ao que esta resolução comunica)
Como corrigir: decidir qual das duas identidades é a pretendida, porque só o utilizador o pode fazer. Se a mudança é intencional — o controlo foi republicado e o que mudou foi revisto — adotá-la com a atualização direcionada que a mensagem descreve, que resolve de novo esse plugin e reescreve a sua entrada. Se não era esperada, a identidade registada é a que foi revista: restaurar a versão ou o artefacto que o ficheiro de confiança indica e investigar porque é que a referência se resolve agora noutro local. Não editar o ficheiro de confiança para resolver esta condição — é uma declaração, confirmada no repositório, do que foi revisto, e um pull comum deixa-o deliberadamente como está, porque adotar silenciosamente um controlo alterado é exatamente o que esta recusa existe para impedir.
A Plugin entity’s claims disagree with the plugin’s own self-report (As afirmações de uma entidade Plugin divergem da autodescrição do próprio plugin)
Uma entidade Plugin indica o que oferece o plugin para o qual aponta: que exportações tem, sobre o que opera cada uma delas e com que âmbito, e — no caso de um plugin que serve um fornecedor — como se comporta ao renderizar. O plugin comunica as mesmas coisas sobre si próprio quando é carregado. Esta condição é o que uma divergência entre os dois comunica.
A comparação é feita por exportação, indexada pelo nome, e corre num só sentido: tudo o que a entidade afirma tem de corresponder, e o plugin pode oferecer mais. Uma entidade que descreve parte da superfície do plugin não é obrigada a enumerar o resto, pelo que uma exportação que o plugin declara e que a entidade omite não é uma divergência. É uma divergência, isso sim, uma exportação afirmada que o plugin não declara, ou uma exportação afirmada cujo operates ou scope difere do que o plugin comunica. O seletor de forma livre não é comparado.
Quando a entidade define também um bloco de comportamento de renderização, os seus campos são comparados um a um — os tipos de entrada, o modo de montagem, o par de delimitadores dos modelos de artefacto, a anotação do nome de montagem, a afirmação de instância reutilizável, a afirmação de ligação entre fronteiras, a afirmação de entradas omitidas e o diretório de aninhamento — e o primeiro a divergir é o que é indicado. Uma entidade que não define nenhum bloco deste tipo salta essa comparação por completo.
A mesma verificação é executada na publicação, pelo que uma incompatibilidade surge normalmente antes de a entidade ser publicada, e não quando uma compilação a carrega.
Mensagens emitidas. Uma exportação afirmada que o plugin não tem:
entity "<entity>" claims export "<export>", which the plugin’s describe() does not declare: wasm: entity contract claim does not match plugin describe() (a entidade afirma uma exportação que o describe() do plugin não declara: wasm: a afirmação do contrato da entidade não corresponde ao describe() do plugin)
um campo de uma exportação afirmada:
entity "<entity>" export "<export>" declares operates "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (a exportação da entidade declara um valor de operates, mas o describe() do plugin comunica outro: wasm: a afirmação do contrato da entidade não corresponde ao describe() do plugin)
e um campo de comportamento de renderização, comunicado com a mesma estrutura, indicando o campo que divergiu:
entity "<entity>" declares boundary_assembly "<claimed>" but the plugin’s describe() reports "<reported>": wasm: entity contract claim does not match plugin describe() (a entidade declara um valor de boundary_assembly, mas o describe() do plugin comunica outro: wasm: a afirmação do contrato da entidade não corresponde ao describe() do plugin)
Como corrigir: é a afirmação da entidade Plugin que tem de ser corrigida, não o Aggregate nem a Release. Deve alinhar-se a afirmação com o que o plugin comunica — a mensagem indica os dois valores, pelo que o sentido em que tem de mudar é visível na própria mensagem. Quando se publica a entidade, regenerá-la a partir do binário é a forma fiável de fazer os dois concordarem; quando se consome uma entidade publicada, deve selecionar-se uma versão cuja afirmação corresponda ao binário para o qual aponta e comunicar a divergência a quem a publicou.
A Plugin entity’s recorded command set does not match the plugin (O conjunto de comandos registado de uma entidade Plugin não corresponde ao plugin)
Um plugin que contribui com comandos de terminal tem esses comandos registados na sua entidade Plugin. Esse registo é escrito automaticamente, e não por um autor: é lido do plugin e anotado, pelo que reflete exatamente o binário. Esta condição é o que comunica um registo que deixou de o refletir — uma diferença no nome de um comando, no seu texto de ajuda curto ou na ordem pela qual os comandos são declarados.
A comparação é de igualdade total, e isso é deliberado. As afirmações de capacidades e de exportações noutras partes da entidade são curadas: um autor pode legitimamente descrever parte da superfície e deixar o resto de fora, pelo que são verificadas como um subconjunto. O registo de comandos não é curado, pelo que qualquer coisa aquém de uma concordância exata significa que o registo se afastou do que o plugin realmente oferece, e uma lista de comandos próxima mas não correta é o que encaminharia mal uma invocação.
Um plugin carregado sem uma entidade não é verificado aqui. O registo está na entidade, pelo que os bytes carregados diretamente não trazem nenhum e a comparação não tem com que ser executada.
Mensagem emitida, que indica os dois conjuntos e como registá-los novamente:
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 o plugin indicado, o espelho de comandos registado não corresponde aos comandos do describe() do plugin; executar novamente a sincronização de plugins e fazer commit do resultado: wasm: o espelho de comandos registado não corresponde ao describe() do plugin)
A mesma comparação na publicação comunica os conjuntos sem a instrução para os registar novamente:
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 o plugin indicado, o espelho de comandos registado não corresponde aos comandos do describe() do plugin: wasm: o espelho de comandos registado não corresponde ao describe() do plugin)
Como corrigir: registar novamente o conjunto a partir do binário e fazer commit do resultado — a mensagem indica o comando que o faz. O registo não deve ser editado manualmente para corresponder: é gerido automaticamente, e uma edição manual que hoje concorde é derivada de novo e substituída da próxima vez que for registado. Quando se consome uma entidade publicada em vez de a publicar, a entidade foi publicada com um registo que o seu próprio binário não sustenta, e essa é uma questão para quem a publicou.
A Plugin entity’s recorded version does not match the plugin (A versão registada de uma entidade Plugin não corresponde ao plugin)
Um plugin comunica a versão que a sua compilação nele registou, e a sua entidade Plugin também regista uma versão; as duas têm de ser a mesma cadeia. As receitas de compilação com que os plugins do Aggrega são construídos tiram essa versão da etiqueta que lança o plugin — a própria etiqueta do compilador para um plugin distribuído com o compilador, uma etiqueta própria do plugin para um distribuído fora dele —, pelo que uma compilação do commit indicado pela etiqueta comunica a versão de lançamento, e uma compilação de qualquer outro commit comunica uma versão de desenvolvimento como 1.0.0-3-g1a2b3c4. Esta condição é o que comunica um par que se separou, e é verificada antes de qualquer byte ser publicado, para que um par divergente não chegue a um catálogo.
A comparação é uma correspondência exata de cadeias. Um plugin construído sem uma versão de compilação registada comunica uma versão vazia, e esse valor vazio é então aquele a que a versão da entidade tem de ser igual — a verificação não trata «nenhuma versão comunicada» como «qualquer versão aceite», porque o seu objetivo é que a versão de uma entidade publicada diga sempre o que o seu binário realmente comunica.
Mensagem emitida:
plugin "<plugin>": recorded metadata.version "<recorded>" does not match the plugin describe() version "<reported>": wasm: entity metadata.version does not match plugin describe() (para o plugin indicado, o metadata.version registado não corresponde à versão do describe() do plugin: wasm: o metadata.version da entidade não corresponde ao describe() do plugin)
Na publicação, a recusa indica também o ficheiro da entidade, o .wasm e a correção:
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 o Plugin indicado, o metadata.version no ficheiro da entidade não corresponde à versão do describe() do .wasm no caminho indicado — definir metadata.version como o lançamento que está a ser publicado e construir o plugin a partir de um checkout limpo do commit indicado pela etiqueta desse lançamento, para que ele próprio comunique essa versão; para um novo lançamento, fazer commit da entidade com o código-fonte que ela lança e aplicar primeiro a etiqueta a esse commit: para o plugin indicado, o metadata.version registado não corresponde à versão do describe() do plugin: wasm: o metadata.version da entidade não corresponde ao describe() do plugin)
Como corrigir: definir o metadata.version da entidade como o lançamento que está a ser publicado e construir o plugin a partir de um checkout limpo do commit indicado pela etiqueta desse lançamento, para que ele próprio comunique essa versão. Para um novo lançamento, fazer commit da entidade com o código-fonte que ela lança e aplicar primeiro a etiqueta a esse commit — a etiqueta tem de indicar um commit que já contenha a entidade. Não se deve copiar para a entidade a versão que o plugin comunica: uma compilação de qualquer outro commit comunica uma versão de desenvolvimento, e copiá-la publicaria essa compilação sob uma versão que nenhuma etiqueta de lançamento indica. Quando o plugin não comunica versão nenhuma, foi construído sem a sua versão registada; deve construir-se com a versão registada.
A plugin was built from a working tree with uncommitted changes (Um plugin foi construído a partir de uma árvore de trabalho com alterações sem commit)
A compilação de um plugin regista a sua versão a partir do commit de que foi construída, e uma compilação feita a partir de uma árvore de trabalho com alterações sem commit traz a marca -dirty no fim dessa versão — 1.0.0-dirty numa etiqueta, 1.0.0-3-g1a2b3c4-dirty depois de uma. Uma versão assim é uma versão semântica válida, mas indica um commit que não contém os bytes que foram construídos, pelo que ninguém consegue reconstruir o que seria publicado a partir da versão sob a qual seria publicado. Publicar um Plugin recusa um plugin cuja própria versão traga a marca, antes de qualquer byte ser publicado e antes de o registo ser contactado; uma execução de teste também o recusa.
Só a marca é recusada. Uma versão de desenvolvimento construída a partir de um commit, como 1.0.0-3-g1a2b3c4, indica um commit que contém de facto o que foi construído, e é publicada; o mesmo acontece com uma versão de pré-lançamento como 1.0.0-rc.1. Validar um plugin face à sua entidade fora de uma publicação não desencadeia esta condição, uma vez que uma compilação em desenvolvimento é rotineiramente feita a partir de uma árvore editada.
A verificação lê a versão que o plugin comunica sobre a sua própria compilação, e é executada antes da comparação com o metadata.version da entidade — pelo que um plugin construído com alterações sem commit sob uma entidade que regista a versão limpa é comunicado aqui, e não como uma versão registada que não corresponde ao plugin.
Mensagem emitida, que indica o plugin, a versão que comunica e a solução:
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 o Plugin indicado, o .wasm no caminho indicado foi construído a partir de uma árvore de trabalho com alterações sem commit — definir metadata.version no ficheiro da entidade como o lançamento que está a ser publicado e construir o plugin a partir de um checkout limpo do commit indicado pela etiqueta desse lançamento, para que ele próprio comunique essa versão; para um novo lançamento, fazer commit da entidade com o código-fonte que ela lança e aplicar primeiro a etiqueta a esse commit: o plugin foi construído a partir de uma árvore de trabalho com alterações sem commit, pelo que nenhum commit reproduz a versão que comunica (com o plugin e a sua versão do describe(), que termina com a marca dirty))
Como corrigir: construir o plugin a partir de um checkout limpo do commit indicado pela etiqueta do lançamento, para que comunique a versão de lançamento que a entidade regista. Para lançar a própria alteração, definir o metadata.version da entidade como o novo lançamento, fazer commit da entidade com a alteração, aplicar a etiqueta a esse commit e construir aí. Fazer commit da alteração e reconstruir, por si só, não abre caminho a um lançamento: o plugin reconstruído comunica uma versão de desenvolvimento, e copiá-la para a entidade publicaria a compilação sob uma versão que nenhuma etiqueta de lançamento indica.
A Plugin entity’s recorded host functions do not match the binary (As funções host registadas de uma entidade Plugin não correspondem ao binário)
Um plugin declara quais das chamadas próprias do host utiliza, e esse conjunto é registado na sua entidade Plugin quando o plugin é publicado — lido do próprio binário, e não escrito por um autor. Quando o plugin é obtido, o conjunto é derivado de novo dos bytes cujo conteúdo acabou de ser verificado, e comparado com o registo. Uma diferença em qualquer dos sentidos interrompe a obtenção.
Isto assenta sobre a fixação do conteúdo em vez de a repetir, e deteta duas coisas que a fixação sozinha não deteta: um binário publicado por algo que não o caminho de publicação habitual, que não traz registo nenhum ou traz um que não descreve os seus próprios bytes; e um defeito no próprio passo de registo. A fixação estabelece que os bytes são os bytes que foram fixados; isto estabelece que o que foi anotado sobre eles é verdadeiro para eles.
Uma entidade que não traz registo é comparada com um conjunto vazio, que corresponde a um plugin que não utiliza nenhuma das chamadas do host — a mesma concordância benigna num sentido e noutro, pelo que uma entidade sem registo não é recusada por não ter um.
Mensagem emitida, que indica o plugin, os dois conjuntos e o artefacto de onde vieram os 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 o plugin indicado, o spec.runtime.hostFunctions carimbado não corresponde ao conjunto derivado do .wasm verificado: wasm: o registo carimbado de funções host não corresponde às importações do .wasm)
A mesma comparação, executada enquanto um plugin está a ser validado, comunica os dois conjuntos sem o 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 o plugin indicado, o registo de funções host registado não corresponde às importações do .wasm: wasm: o registo carimbado de funções host não corresponde às importações do .wasm)
Como corrigir: nada nos ficheiros de entidade causa isto e nenhuma alteração ao que se escreve o resolve. Deve publicar-se novamente o plugin pelo caminho de publicação habitual, que deriva o registo do binário e escreve os dois em conjunto. Quando se consome um plugin publicado, a entidade e o binário para o qual aponta foram publicados dessincronizados, pelo que se deve comunicar a incompatibilidade a quem o publica, citando os dois conjuntos da mensagem — e não editar manualmente o registo para que concorde, uma vez que é derivado, e não escrito, e a derivação seguinte descarta a edição.
The lockfile no longer matches what the release resolves to (O ficheiro de bloqueio já não corresponde àquilo em que a Release se resolve)
O ficheiro de bloqueio de uma Release fixa cada entidade, biblioteca e plugin que a Release alcança, cada um com a versão selecionada e um digest, e regista os próprios ficheiros de Release — a Release e cada Release que ela estende — pelo digest do respetivo conteúdo. O digest de uma entidade abrange o que uma publicação dela transporta: o seu documento e cada ficheiro que nomeia ao seu lado, cada um pelo seu caminho e pelos seus bytes. O de uma biblioteca e o de um plugin abrangem os respetivos bytes. Resolver novamente a Release produz o mesmo conjunto, e os dois são comparados. Esta condição é o que um desacordo comunica.
Todos os desacordos são recolhidos antes de qualquer um deles ser comunicado, em tudo o que o ficheiro de bloqueio fixa, para que uma única execução mostre o quadro completo em vez de uma entrada de cada vez.
São comunicadas estas estruturas de desacordo, e vale a pena distingui-las porque as soluções diferem:
Uma referência que o ficheiro de bloqueio não fixa. A Release alcança agora algo para o qual o ficheiro de bloqueio não tem entrada — uma dependência acrescentada desde o pull que o escreveu. A entrada nomeia o local onde a Release a pede, pelo que uma Recipe ou FeatureRecipe que o Manifest associa é comunicada com a entrada de mapeamento que a associa, e uma que o nível name associa nomeia a instância ou o anexo para o qual foi escolhida.
Uma referência fixada que a Release já não alcança. O ficheiro de bloqueio ainda fixa algo de que já nada na Release depende.
Um ficheiro de Release editado desde o pull. A Release, ou uma Release que ela estende, já não contém os bytes que o ficheiro de bloqueio registou para ela. Tudo o que a Release pede — que versão da fonte obter, que componentes colocar onde — é resolvido a partir do que o ficheiro contém, pelo que as fixações registadas podem já não descrever o que ela pede agora. Isto é comunicado aqui, antes de qualquer renderização, em vez de como aquilo em que a renderização teria falhado: uma versão da fonte editada surgiria de outro modo mais tarde como uma obtenção que não encontra nenhuma fixação. Um ficheiro de bloqueio que não regista nenhum ficheiro de Release comunica a Release como não registada, e um ficheiro de Release que a Release já não estende é comunicado como já não lido.
Uma referência de fonte que se moveu no seu remoto. Uma fonte escrita num ref: do git é registada no commit para o qual o ref se resolveu. Cada pull que não é uma atualização pergunta ao remoto para onde o ref aponta agora, e o mesmo faz aggrega pull --verify onde a rede está acessível; um ref que se resolve para um commit diferente é comunicado aqui em vez de adotado. Apenas esses dois o comunicam: uma compilação lê o commit registado e não pergunta.
A comparação incide sobre o conteúdo, pelo que um conteúdo idêntico alcançado por outra via não diverge: o que tem de diferir para que isto dispare são os bytes. Para um ficheiro de Release, isso inclui um comentário ou uma alteração de espaços em branco, exatamente como acontece com o Aggregate e o Manifest que a Release nomeia. Para uma entidade, é o conteúdo do que ela transporta, pelo que a mesma entidade lida de um diretório de catálogo e obtida de um registo não diverge, nem um checkout cujos ficheiros diferem apenas nos bits de permissão, incluindo o bit de execução, nem uma publicação cujo arquivo foi comprimido de outra forma.
Mensagem emitida. A própria frase da condição abre-a, e segue-se cada divergência recolhida, cada uma indicando o seu eixo — e, para uma entidade, o seu tipo, porque uma entidade é identificada pelo tipo e pelo URI em conjunto; assim, uma Release cujo Aggregate e cujo Manifest partilham um nome tem duas entradas, e uma edição em qualquer um deles é reportada relativamente ao que foi editado:
lockfile: out of date; it no longer matches what its Release resolves to: entity "<uri>" (<kind>) not in lockfile (referenced from <site>) (lockfile: desatualizado; já não corresponde àquilo em que a sua Release se resolve: entidade, com o seu tipo, ausente do ficheiro de bloqueio, com o local de onde é referenciada) <axis>"<uri>" changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (a referência indicada mudou no eixo indicado: a versão e o digest do ficheiro de bloqueio diferem dos atuais) entity "<uri>" (<kind>) changed: lockfile=(<version>,<digest>) current=(<version>,<digest>) (a entidade indicada, do tipo indicado, mudou: a versão e o digest do ficheiro de bloqueio diferem dos atuais) <axis>"<uri>" no longer used by the release (a referência indicada no eixo indicado já não é usada pela Release) release document "<file>" was edited after the lockfile was written: its content no longer matches the recorded digest (lockfile=<digest> current=<digest>), so the pins may no longer describe what it asks for; re-resolving the Release records the files it reads as they now stand (o documento de Release indicado foi editado depois de o ficheiro de bloqueio ter sido escrito: o seu conteúdo já não corresponde ao digest registado, pelo que as fixações podem já não descrever o que pede; resolver novamente a Release regista os ficheiros que lê tal como estão agora)
<site> é o local onde a Release pede a referência, escrito como o caminho até à entrada que a nomeia — manifest.spec.mappings.components.name.db-primary, por exemplo — com até três desses locais listados por ordem e ... depois deles quando há mais. Uma referência cuja resolução não regista nenhum local deste tipo é comunicada sem o parêntese.
Um pull que comunica uma referência de fonte que se moveu nomeia o artefacto tal como o seu autor o escreveu, com chart= e module_subdir= onde a fonte os nomeia:
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: a referência indicada moveu-se — o ficheiro de bloqueio fixa um commit, e agora resolve-se para outro; adotar o destino atual com um pull de atualização)
Uma compilação imprime a solução depois das entradas:
run aggrega pull --release <release> to re-resolve the Release and rewrite its lockfile (executar o pull para resolver novamente a Release e reescrever o respetivo ficheiro de bloqueio)
Que comandos obrigam uma release a corresponder ao seu ficheiro de bloqueio.aggrega build compara antes de renderizar e interrompe-se. aggrega validate --release e todas as seleções de aggrega inspect que resolvem uma release — a vista predefinida, --resolved, --ir-graph e --closure — executam a mesma comparação assim que as dependências da release são resolvidas, e interrompem-se com a mesma mensagem e a mesma correção, sem escrever nada na saída padrão; assim, nenhum deles deixa passar um ficheiro de bloqueio que uma compilação recusa por estar desatualizado. As ferramentas do assistente build, validate com um release e describe com um release recusam nos mesmos termos. aggrega pull executa a comparação contra o ficheiro de bloqueio que está prestes a escrever, e aggrega pull --verify contra o que está no disco. Um comando que não resolve nenhuma release — aggrega validate sem argumento, que lê as fixações do ficheiro de bloqueio apenas para encontrar um pai de extends, ou com o caminho de uma entidade, e aggrega inspect --raw ou --output yaml sem --ir-graph — não fica sujeito a um ficheiro de bloqueio, nem uma release sem ficheiro de bloqueio ao lado. O servidor de linguagem do editor interrompe as suas compilações por esse motivo e, num pedido de grafo, reporta-o como um aviso no ficheiro de bloqueio, continuando a desenhar o grafo.
Como corrigir: resolver novamente a Release e fazer commit do ficheiro de bloqueio reescrito. Para tudo o que uma compilação comunica, um simples aggrega pull --release <release> — o comando que a compilação imprime — é toda a correção: resolve a Release tal como está agora, reescreve as fixações que se moveram e mantém todas as outras, pelo que nada em que não se tenha tocado se move. Onde o que se moveu é um ficheiro sob a fonte local de uma Recipe ou de uma FeatureRecipe, esse pull interrompe-se primeiro a nomear aggrega pin para a entidade, porque registar a nova fixação ao lado dela é o passo do autor; pode executá-lo, ou passar --pin-sources ao pull, e o pull elimina a divergência. A única entrada que um simples pull não elimina é uma referência de fonte que se moveu no seu remoto, porque eliminá-la significa adotar o commit que a referência nomeia agora: aggrega pull --upgrade --release <release> faz isso, e a entrada di-lo — onde o entity.lock da Recipe regista essa fonte, a atualização interrompe-se da mesma forma até o novo commit ser fixado ao lado dela. Convém ler as entradas antes de o fazer, porque a terceira estrutura é a que merece uma pausa: uma referência que a Release já não alcança é normalmente uma dependência removida de propósito, mas, se não foi removida, outra coisa mudou que a tornou inalcançável. Um par que se moveu numa referência em que não se tocou significa que o conteúdo nessa versão não é o conteúdo que foi revisto, o que é uma questão para quem o fornece, e não algo a adotar sem olhar.
Um pull executa esta mesma comparação com o ficheiro de bloqueio que está prestes a escrever e não escreve um que a comparação recuse, pelo que um ficheiro de bloqueio que um pull acabou de escrever passa nela numa compilação que recebe as mesmas entradas. Onde esta condição regressa logo a seguir a um pull que foi concluído, as duas execuções receberam entradas diferentes: um diretório de catálogo passado a uma e não à outra, ou uma configuração do espaço de trabalho editada entre elas. O pull e a compilação devem ser executados sobre as mesmas entradas.
An artifact is not at the source the build was told to find it (Um artefacto não está na fonte onde a compilação foi instruída a encontrá-lo)
Uma referência de catálogo nomeia um artefacto e uma versão. Esta condição comunica que nada responde a esse par — nem no registo para o qual a referência se resolve, nem na cache local de artefactos a partir da qual a compilação lê.
Uma compilação lê a cache; não sai para o exterior por iniciativa própria. A aquisição é um passo separado: o pull que resolve uma Release obtém aquilo de que a Release precisa e escreve-o na cache, e a compilação lê depois o que lá está. Assim, esta condição chega a uma compilação como uma falha de cache, e chega a um pull como um registo que não tem esse artefacto. Onde uma compilação está configurada para preencher o seu ficheiro de bloqueio ao arrancar, a aquisição que executa é esse mesmo pull.
Mensagens emitidas. Um registo sem essa etiqueta, e uma obtenção que resolveu um manifesto cujo blob de conteúdo está ausente:
oci: "<reference>:<version>": oci: artifact not found at remote source (oci: para a referência e a versão indicadas: oci: artefacto não encontrado na fonte remota)
oci: content for "<reference>:<version>": oci: artifact not found at remote source (oci: conteúdo para a referência e a versão indicadas: oci: artefacto não encontrado na fonte remota)
uma leitura da cache que não encontrou nenhuma entrada, que é a estrutura com que uma compilação se depara:
oci: cache miss for <reference>@<version>: oci: artifact not found at remote source (oci: falha de cache para a referência e a versão indicadas: oci: artefacto não encontrado na fonte remota)
e o mesmo para um artefacto em cache cujo manifesto está em falta ao seu lado:
oci: manifest cache miss for <reference>@<version>: oci: artifact not found at remote source (oci: falha de cache do manifesto para a referência e a versão indicadas: oci: artefacto não encontrado na fonte remota)
Como corrigir: verificar primeiro a referência e a versão — uma versão que já não existe e um nome com uma gralha produzem a mesma resposta, e a mensagem cita ambos para que possam ser comparados com o catálogo. Onde a referência está correta, o artefacto não foi adquirido: executar o pull para a Release, que obtém o que a Release alcança e preenche a cache. Onde o espaço de trabalho está offline, esse pull tem de ser executado a partir de um local com acesso à rede; uma compilação offline lê apenas o que já está em cache, e é isto que diz quando a cache não o contém.
The registry will not serve an artifact without credentials it accepts (O registo não serve um artefacto sem credenciais que aceite)
O registo respondeu, e recusou: ou não foram apresentadas credenciais, ou as apresentadas não foram aceites. Distingue-se de um registo que não pôde de todo ser alcançado — aqui a conversa aconteceu e a resposta foi não.
Quatro momentos comunicam-na, todos enquanto artefactos estão a ser adquiridos ou publicados: a resolução de uma referência, o pull do seu conteúdo, a listagem das versões que um repositório contém, e a verificação de uma credencial no momento em que é guardada.
Mensagens emitidas, cada uma a nomear o que estava a ser pedido e a citar o que o registo respondeu:
oci: resolve "<reference>:<version>": <what the registry replied>: oci: authentication required or failed (oci: resolução da referência indicada, com a resposta do registo: oci: autenticação necessária ou falhada)
a listagem das versões de um repositório, que nomeia antes o estado:
oci: tags/list "<repository>": status <code>: oci: authentication required or failed (oci: tags/list do repositório indicado, com o código de estado: oci: autenticação necessária ou falhada)
e a verificação de uma credencial enquanto é guardada:
oci: verify credential for "<host>": <what the registry replied>: oci: authentication required or failed (oci: verificação da credencial para o host indicado, com a resposta do registo: oci: autenticação necessária ou falhada)
Onde a falha é revelada por um passo que fornece correção, a linha termina com o início de sessão a executar no host que derivou:
remediation: aggrega login <host> (or docker login <host>) before re-running aggrega pull —release <release> (correção: executar aggrega login, ou docker login, para o host indicado antes de voltar a executar aggrega pull —release para a Release indicada)
e, quando uma importação estava a obter um dos importadores core do compilador, o mesmo login antes de voltar a executar a importação:
remediation: aggrega login <host> (or docker login <host>) before re-running the import (correção: aggrega login (ou docker login) antes de voltar a executar a importação)
Um repositório clássico de charts do Helm ou um arquivo de chart, um fragmento de compose e um repositório Git obtidos por http ou https também comunicam esta condição quando o servidor recusa o pedido como não autorizado, e a sua remediação indica a entrada do netrc a adicionar em vez de um início de sessão, já que é nesse ficheiro que essas obtenções leem a sua credencial:
remediation: add an entry for <host> (machine <host> login <user> password <secret>) to the netrc file <path>, then run the command again (remediação: adicionar ao ficheiro netrc uma entrada para o host (com machine, login e password) e depois executar novamente o comando)
Como corrigir: isto cabe ao operador e não ao autor da entidade — nada num Aggregate, num Component ou numa Recipe o causa. O hub oficial, hub.aggrega.ai, serve a qualquer pessoa o que publica, pelo que ler a partir dele não requer credencial, ao passo que publicar nele requer; outro registo pode exigir uma credencial também para a leitura. Iniciar sessão no host que a mensagem nomeia — ou, para uma origem obtida por http ou https, adicionar a entrada do netrc que a remediação nomeia — e executar novamente a aquisição. Se a sessão já estiver iniciada, a credencial no armazenamento não é uma que esse host aceite para esse repositório: iniciar sessão novamente para a renovar, e verificar se a conta tem acesso de leitura ao repositório para o qual a referência se resolve, já que um repositório privado responde exatamente assim a uma conta que não o pode ver. Onde a referência se resolve para um host inesperado, o alias de registo ou o registo predefinido em .aggrega-config.yaml está a apontar para outro lado.
The netrc file cannot be read (O ficheiro netrc não pode ser lido)
Um repositório clássico de charts do Helm ou um arquivo de chart, um fragmento de compose e um repositório Git obtidos por http ou https vão buscar a sua credencial ao ficheiro netrc, que é lido quando uma fonte deste tipo é obtida — por um pull, uma fixação ou uma compilação que preenche o seu ficheiro de bloqueio. Que ficheiro é lido, e que entrada responde a um pedido, está descrito em Autenticação. Esta condição comunica um ficheiro netrc que existe e não pôde ser usado: não pôde ser lido — é um diretório, por exemplo, ou não há permissão para o ler — ou não segue o formato netrc. O formato é lido de forma estrita, porque uma palavra lida no sítio errado desloca todas as palavras seguintes: uma palavra-chave mal escrita transformaria de outro modo a palavra-passe seguinte na palavra-chave seguinte, e o pedido sairia sem credencial, ou com a errada, enquanto o ficheiro parecia correto.
Um ficheiro que não existe não é esta condição: não contém credenciais, e um pedido que precisa de uma recebe como resposta a recusa do servidor. Um ficheiro que outros utilizadores da máquina podem ler também não é esta condição: no Linux e no macOS gera um aviso que nomeia o ficheiro, e é lido mesmo assim.
A mensagem nomeia o ficheiro e, para um defeito de formato, a linha, e diz o que está errado apenas em termos do formato — nunca uma palavra que o ficheiro contenha, já que uma palavra fora do sítio pode ser uma palavra-passe. O diagnóstico não tem categoria: o ficheiro netrc é o ficheiro de credenciais do próprio utilizador e não um documento que a compilação lê.
Mensagem emitida para um defeito de formato, que é um destes: uma palavra onde se espera uma palavra-chave, uma palavra-chave não seguida do seu valor, um login, password ou account antes de qualquer entrada machine ou default, e uma palavra entre aspas não fechada na linha em que 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 (não foi possível ler o ficheiro netrc: no ficheiro e na linha indicados há uma palavra onde se espera uma palavra-chave (machine, default, login, password, account ou macdef). Corrigir o ficheiro, ou definir NETRC com o caminho de outro ficheiro netrc a ler em vez deste)
e para um ficheiro que não pôde ser lido, a citar o motivo:
the netrc file could not be read (file <path>, <why it could not be read>). Correct the file, or set NETRC to the path of another netrc file to read instead (não foi possível ler o ficheiro netrc: o ficheiro indicado, com o motivo pelo qual não pôde ser lido. Corrigir o ficheiro, ou definir NETRC com o caminho de outro ficheiro netrc a ler em vez deste)
Como corrigir: abrir o ficheiro que a mensagem nomeia. Para um defeito de formato, ir à linha que nomeia: cada entrada é machine <host> — ou default — seguida de login <user> e password <secret>, e uma palavra-chave mal escrita ou deixada sem o seu valor é a causa habitual. Para um ficheiro que não pôde ser lido, torná-lo um ficheiro que se possa ler, legível apenas pelo próprio utilizador (chmod 600). Onde o ficheiro não for o que se pretendia que fosse lido, definir NETRC com o caminho do pretendido.
The registry could not be reached (Não foi possível contactar o registo)
A conversa com o registo nunca aconteceu: a resolução de nomes, a ligação ou o handshake seguro falhou. É a contrapartida de um registo que respondeu e recusou — aqui nada ficou estabelecido num sentido ou noutro, pelo que o estado do artefacto na outra extremidade é desconhecido, em vez de se saber que falta.
É também o que uma falha de transporte sem causa mais específica comunica enquanto a fonte de uma Recipe está a ser adquirida, pelo que, nesse caminho, é a resposta geral «não foi possível contactar a outra extremidade» e não uma afirmação sobre qual o nível que falhou.
Mensagem emitida, que nomeia a fonte em aquisição e cita a falha de transporte subjacente, com a correção que a condição traz:
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: com o tipo, o URL e a versão indicados: oci: rede inacessível (causa: a falha de transporte); correção: verificar a conectividade de rede ao host indicado; os proxies empresariais precisam normalmente de HTTPS_PROXY exportada)
Como corrigir: a correção cabe ao operador e está fora do catálogo. Verificar que o host indicado na mensagem está acessível a partir do local onde o comando é executado. Quando o ambiente chega à rede através de um proxy, o proxy tem de ser exportado para o ambiente, como indica a correção — um proxy configurado apenas para um navegador ou um gestor de pacotes não será detetado. Quando o host está acessível manualmente mas não a partir daqui, a diferença está geralmente em credenciais num proxy ou num certificado de interceção que o handshake não aceitou. Depois de os artefactos estarem em cache, as compilações seguintes leem a cache e não precisam de todo da rede.
A server did not answer in time (Um servidor não respondeu a tempo)
Um pedido ficou à espera do servidor a que se dirigia — um registo, ou qualquer outro servidor que um comando alcance, como o log de transparência em que uma assinatura fica registada — e foi retirado. Um pedido espera no máximo 30 segundos que o servidor comece a sua resposta depois de o pedido ter sido enviado na totalidade, e no máximo 30 segundos pela parte seguinte de uma resposta que já está a chegar; ultrapassado qualquer um dos dois, é recusado sob esta condição, que indica o servidor e a espera. É o que produz um servidor que aceita uma ligação e nunca responde, e o que produz também um endereço que nunca aceita nenhuma, em vez de um comando que espera sem fim. Um percurso de toda a listagem de repositórios de um registo espera, pelo contrário, em cada página durante o tempo que o percurso puder durar, e é limitado por uma condição própria, E0377.
Só a espera é limitada. Uma transferência ou um carregamento que continue a avançar demora o tempo que demorar, porque a espera só é medida enquanto nada chega. Um chart do Helm que o source: de uma Recipe obtém por HTTPS fica sujeito apenas à espera pelo início da sua resposta, e essa expiração é comunicada nas próprias palavras da biblioteca de rede em vez de sob esta condição. Um pedido que um comando já repete quando esgota o tempo — uma leitura durante aggrega registry update, uma escrita durante uma publicação — é primeiro repetido, pelo que a recusa é o que resta depois da sua última tentativa.
Mensagem emitida, para uma listagem de versões a que o registo não respondeu:
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 as versões de plugin/cli/mo: oci: listar as tags: Get: 127.0.0.1:18471 não respondeu em 30s: egress: o servidor não respondeu a tempo)
e para uma resposta que parou a meio:
<host> stopped answering: nothing more of its answer arrived for 30s: egress: the server did not answer in time (deixou de responder: nada mais da sua resposta chegou durante 30s: egress: o servidor não respondeu a tempo)
Como corrigir: a correção cabe ao operador e está fora do seu catálogo. Verifique se o servidor indicado na mensagem está em funcionamento e acessível a partir do local onde o comando é executado; um registo sob carga ou em manutenção volta a responder mais tarde, e basta executar o comando novamente. Quando o ambiente acede à rede através de um proxy, verifique se o proxy reencaminha o pedido em vez de o reter. A espera é fixa; não existe nenhuma definição que a prolongue.
A registry’s repository listing did not end in time (A listagem de repositórios de um registo não terminou a tempo)
Um percurso de toda a listagem de repositórios de um registo durou cinco minutos sem chegar ao fim da listagem e foi interrompido. Dois comandos percorrem a listagem: aggrega plugin add, apenas quando nenhum plugin tem exatamente o nome que lhe foi dado e procura um cujo nome o contenha, e aggrega registry update, que lista os repositórios de um registo antes de ler cada um deles. Uma listagem que continua a nomear novos repositórios sem fim e uma que um registo serve demasiado devagar para terminar acabam ambas aqui em vez de prender o comando; o percurso não produz nenhum repositório, pelo que nada é escolhido nem indexado a partir de uma listagem que foi cortada. A mensagem indica quantos repositórios a listagem tinha nomeado quando foi interrompida.
Mensagem emitida, para a adição de um plugin cuja consulta é parte de um nome:
aggrega plugin add: 127.0.0.1:18472: no cli plugin is named “mo”, and searching every repository for a name containing it did not finish; name the plugin exactly, as aggrega plugin add cli <name>: the walk was stopped after 5m0s, before the listing ended (repositories named so far: 146): registry: the repository listing did not end in time (aggrega plugin add: 127.0.0.1:18472: nenhum plugin cli se chama «mo», e a pesquisa em cada repositório por um nome que o contenha não terminou; indique o nome exato do plugin, como em aggrega plugin add cli seguido do nome: o percurso foi interrompido após 5m0s, antes do fim da listagem (repositórios nomeados até agora: 146): registry: a listagem de repositórios não terminou a tempo)
Como corrigir: para aggrega plugin add, indique o nome exato do plugin — aggrega plugin add cli moo em vez de aggrega plugin add cli mo —, o que procura o plugin por esse nome com um único pedido e nunca percorre a listagem. Para aggrega registry update, a causa é a listagem do registo: confirme junto de quem gere o registo que a listagem termina, e execute novamente a atualização quando isso acontecer. O limite de cinco minutos é fixo; não existe nenhuma definição que o prolongue.
A registry kept asking to slow down (Um registo continuou a pedir para abrandar)
Um registo demasiado ocupado responde 429 Too Many Requests, ou 503 Service Unavailable com um cabeçalho Retry-After que indica quanto tempo esperar. Cada pedido que um comando faz a um registo espera o tempo que o registo pede — dez segundos quando não o diz — e é feito de novo; cada pedido a esse registo espera com ele, e são-lhe enviados menos pedidos em simultâneo até voltar a responder. Um registo que durante cinco minutos não responde mais nada além de «abrande» é recusado com esta condição, indicando o registo, a sua última resposta e há quanto tempo não respondia outra coisa, e o mesmo acontece a um pedido cujo próprio limite de tempo termina enquanto espera. aggrega registry update indica então esse registo como não indexado, e este mantém o índice que tinha antes da execução.
Mensagem emitida, para um registo que pediu para abrandar 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 (continuou a pedir para abrandar: a sua última resposta foi 429 Too Many Requests, e não tinha respondido outra coisa durante 5m0s: oci: o registo continuou a pedir para abrandar)
e para um pedido cujo próprio limite de tempo pôs fim à 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 (continuou a pedir para abrandar: a sua última resposta foi 429 Too Many Requests, e não tinha respondido outra coisa quando o próprio tempo do pedido se esgotou: oci: o registo continuou a pedir para abrandar)
Como corrigir: a causa é o limite de pedidos do registo, não algo que tenha escrito. Um registo que limita a rapidez com que um cliente pode fazer pedidos limita normalmente tudo o que vem do mesmo endereço, por isso verifique se outros comandos ou máquinas por trás desse endereço lhe estão a fazer pedidos ao mesmo tempo, e execute o comando de novo quando tiverem terminado. Se o registo for gerido por si, verifique o seu limite de pedidos. O limite de cinco minutos é fixo; não existe nenhuma definição que o prolongue.
Fetched or cached bytes do not match the digest committed for them (Os bytes obtidos ou em cache não correspondem ao digest declarado para eles)
Cada artefacto traz um manifesto que declara o digest do seu conteúdo, e o ficheiro de bloqueio fixa de forma independente o digest desse manifesto. Ambas as declarações são verificadas recalculando o hash dos bytes disponíveis e comparando. É isto que uma comparação falhada comunica, e dispara da mesma forma sobre bytes acabados de obter e sobre bytes relidos da cache.
Duas condições, e a que dispara indica qual o nível que divergiu. Uma nomeia conteúdo que não corresponde ao digest que o seu próprio manifesto declara. A outra nomeia um manifesto em cache que não corresponde ao digest que o ficheiro de bloqueio fixou para ele — a verificação que impede que um manifesto adulterado se torne a autoridade em que uma verificação de conteúdo posterior confia. A fixação é o que dá sentido a essa segunda verificação: vem do ficheiro de bloqueio, em vez de voltar a derivar o manifesto a partir dos bytes em cache, pelo que as duas são verdadeiramente independentes.
Uma entidade é depois confrontada com a sua própria linha, acima do que os bytes trazem. Depois de os bytes de uma entidade em cache concordarem com o seu manifesto, são comparados com o digest que o ficheiro de bloqueio regista para a entidade, que abrange os ficheiros que a sua publicação traz — cada um pelo seu caminho e pelos seus bytes — em vez dos bytes comprimidos. Assim, os mesmos ficheiros publicados com outra compressão continuam a concordar, enquanto ficheiros diferentes sob a mesma versão não, e uma divergência é comunicada sob a condição de conteúdo. Um pull que respeita uma fixação faz a mesma comparação sobre o que um registo serve sob a versão fixada.
Nenhuma destas verificações precisa da rede. Cada uma é uma comparação de hashes sobre bytes já disponíveis, o que permite a uma compilação totalmente offline estabelecer ainda assim que o que está a ler é o que foi fixado.
Mensagens emitidas. O conteúdo face ao seu manifesto:
oci: content digest <computed> != manifest layer <committed>: oci: content digest mismatch (oci: o digest calculado do conteúdo difere do declarado pela camada do manifesto: oci: divergência do digest de conteúdo)
uma entidade de plugin, que um manifesto declara noutra posição:
oci: config digest <computed> != manifest config <committed>: oci: content digest mismatch (oci: o digest calculado da configuração difere do da configuração do manifesto: oci: divergência do digest de conteúdo)
um manifesto em cache face ao digest fixado:
oci: cached manifest digest <computed> != pinned <pinned>: oci: cached manifest digest mismatch (oci: o digest calculado do manifesto em cache difere do fixado: oci: divergência do digest do manifesto em cache)
uma entidade em cache face à sua linha, e um registo que serve outro conteúdo sob uma versão fixada:
catalog: cached <uri> content digest <computed> does not match lockfile pin <pinned>: oci: content digest mismatch (catalog: o digest de conteúdo da entidade em cache indicada não corresponde à fixação do ficheiro de bloqueio: oci: divergência do digest de conteúdo)
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: divergência do digest de conteúdo: entidade fixada indicada: o registo serve agora para a versão fixada um digest diferente do fixado; executar o pull de atualização para atualizar a fixação)
Ambos são enquadrados pelo que estava a ser lido. Uma entidade fixada que nenhuma fonte contém na sua fixação, com a condição do manifesto quando o manifesto da entrada de cache divergiu e a do conteúdo nos restantes casos:
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> (entidade fixada indicada: nenhuma fonte contém os bytes fixados, com o que cada fonte lida continha; com um registo acessível, o pull volta a obter a versão fixada: a mensagem acima)
Uma entrada de arquivo que nomeia um caminho que sai do arquivo também é comunicada sob a condição de conteúdo, uma vez que um bundle que o tenta não é o bundle que foi declarado:
path traversal entry "<name>": oci: content digest mismatch (entrada indicada com travessia de caminho: oci: divergência do digest de conteúdo)
Ambas trazem a mesma correção quando o passo que as faz surgir fornece uma:
remediation: run aggrega pull —upgrade —release <release> to refresh the lockfile and cache (correção: executar aggrega pull —upgrade —release para a Release indicada, para atualizar o ficheiro de bloqueio e a cache)
Como corrigir: nada nos ficheiros de entidade causa isto e nenhuma alteração de autoria o resolve. Atualizar em conjunto a cache e o ficheiro de bloqueio com aggrega pull --upgrade --release <release>, que volta a obter da fonte e reescreve ambos. Se isso o resolver, a cópia em cache tinha sido alterada ou truncada desde que foi escrita. Se a divergência persistir após uma atualização, os bytes que o publicador serve diferem realmente do que foi fixado — uma versão republicada, o que é uma questão para quem a publica, e que vale a pena colocar antes de adotar o novo digest e não depois.
A manifest carries no layer of the expected kind, or more than one (Um manifesto não traz nenhuma camada do tipo esperado, ou traz mais do que uma)
O manifesto de um artefacto lista as suas camadas, e a que traz o conteúdo é selecionada pelo seu tipo de media e não pela sua posição. É isso que permite a um artefacto agrupar mais do que uma camada — um chart com uma camada de proveniência separada ao lado, por exemplo — e ainda assim ter o conteúdo identificado de forma fiável.
Duas estruturas não deixam nada para selecionar. Nenhuma camada do tipo esperado significa que o manifesto descreve algo diferente do que se supôs que a referência indicava. Mais do que uma significa que a escolha não tem resposta, e escolher a primeira estaria por vezes certo e por vezes silenciosamente errado.
Mensagens emitidas, cada uma a nomear o tipo de media esperado. Nenhuma:
oci: manifest has no layer of media type "<media-type>": oci: manifest has no layer of the expected content media type (oci: o manifesto não tem nenhuma camada do tipo de media indicado: oci: o manifesto não tem nenhuma camada do tipo de media de conteúdo esperado)
e mais do que uma, que nomeia também quantas:
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: o manifesto tem várias camadas do tipo de media indicado; era esperada exatamente uma: oci: o manifesto tem várias camadas do tipo de media de conteúdo esperado)
Como corrigir: a correção cabe ao publicador e não ao utilizador — o manifesto não é algo que um autor de catálogo escreva. Verificar primeiro que a referência aponta para onde se pretendia: uma referência que se resolve para outro tipo de artefacto produz a primeira estrutura, porque o manifesto é um manifesto real de outra coisa. Se a referência estiver correta, o artefacto foi publicado com um manifesto que não o descreve como o tipo que alega ser; há por isso que comunicar o tipo de media da mensagem a quem o publica. Publicar pelo caminho de publicação habitual produz um manifesto com exatamente uma camada de conteúdo, pelo que um artefacto em qualquer das duas estruturas foi montado de outra forma.
A published bundle holds no entity, or holds two (Um bundle publicado não contém nenhuma entidade, ou contém duas)
Uma entidade que declara ficheiros ao lado do seu documento — o chart local de uma Recipe ou o seu lock, o esquema importado de um Component — é publicada como um .tar.gz que agrupa a entidade juntamente com esses ficheiros. Voltar a ler um significa reencontrar a entidade entre eles — e o ficheiro em que foi escrita pode ter qualquer nome, pelo que o que a identifica é o preâmbulo de entidade que traz e não o seu nome. O documento na raiz do bundle cujo kind: é um tipo de entidade publicável é a entidade; um fragmento compose, um modelo de chart ou um manifesto Kubernetes ao lado dele não o é, nem um documento de entidade mais abaixo dentro de uma árvore source/, que é conteúdo que a entidade distribui e não a própria entidade.
Duas estruturas não deixam nada para selecionar, e ambas são propriedades da forma como o artefacto foi publicado.
Nenhum documento de entidade na raiz do bundle. O bundle foi empacotado sem a entidade na sua raiz — o seu documento omitido, ou colocado num subdiretório em vez de ao lado dos ficheiros que traz. A mensagem lista o que a raiz do bundle de facto traz, o que normalmente basta para ver o que aconteceu.
Dois documentos de entidade na raiz do bundle. O bundle foi empacotado a partir de um diretório inteiro em que foram escritas duas entidades — algo que aggrega push nunca faz, uma vez que cada entidade traz apenas os ficheiros que declara, mas que outro cliente pode fazer. Empacotadas assim, cada uma das suas coordenadas publicadas traz os mesmos bytes — pelo que responder com qualquer uma delas devolveria a outra entidade sob o nome pedido, sem que nada a jusante o pudesse notar. Não há nenhuma escolha segura a fazer, pelo que nenhuma é feita.
Mensagens emitidas, que listam o que foi encontrado. Nenhum, quando o bundle traz outros ficheiros:
bundle root carries no entity document among <file>, <file>: oci: published bundle carries no entity document (a raiz do bundle não traz nenhum documento de entidade entre os ficheiros indicados: oci: o bundle publicado não traz nenhum documento de entidade)
nenhum, quando não traz nada:
bundle root carries no files at all: oci: published bundle carries no entity document (a raiz do bundle não traz nenhum ficheiro: oci: o bundle publicado não traz nenhum documento de entidade)
e mais do que um, que nomeia tanto a contagem como os documentos em colisão:
bundle root carries <count> entity documents (<file>, <file>): oci: published bundle carries more than one entity document (a raiz do bundle traz vários documentos de entidade, nos ficheiros indicados: oci: o bundle publicado traz mais do que um documento de entidade)
Como corrigir: resolver ambos cabe ao publicador e não ao utilizador, e a correção está no diretório de versão a partir do qual a entidade foi publicada. Dar a cada entidade um diretório de versão próprio, para que esse diretório contenha uma entidade e os ficheiros que lhe pertencem — a estrutura que toda a entidade publicada já segue, em que o diretório tem o nome do metadata.version da entidade e fica sob o próprio nome da entidade. Depois, publicar de novo numa nova versão: os bytes publicados estão congelados, pelo que republicar sobre a versão existente é recusado e não corrigido. Quem estiver a consumir em vez de publicar deve comunicar a mensagem a quem publica o artefacto; os nomes de ficheiro nela identificam o diretório a dividir.
A published artifact cannot be read as an entity (Um artefacto publicado não pode ser lido como uma entidade)
Ler uma entidade a partir da coordenada em que está publicada começa pelos bytes que o registo aí serve — aggrega inspect oci://… lê-os para que possam ser examinados, e um pull de dependências lê da mesma forma os de um arquivo para encontrar a versão que fixa. Duas estruturas desses bytes não contêm nenhuma entidade para ler.
Um arquivo que não se descompacta. Uma entidade publicada com os ficheiros que declara é publicada como um .tar.gz, e os bytes começam como tal, mas o fluxo de compressão ou o arquivo dentro dele não está bem formado — na maioria das vezes porque foi truncado. Os bytes continuam a corresponder ao digest que o próprio manifesto do artefacto regista para eles, pelo que são exatamente o que foi publicado: o dano ocorreu antes ou durante a publicação e não no caminho até ao utilizador.
Um documento que não é uma entidade. A coordenada traz um único documento, e este não é analisado, não declara nenhum kind: ou declara um tipo que nunca é publicado, como uma Release ou um Manifest. A referência nomeia então algo publicado ao lado do catálogo em vez de uma entidade — um artefacto de dados publicado com aggrega push-artifact, por exemplo.
Mensagens emitidas. Um arquivo cujo fluxo de compressão não está bem formado, com o erro que o interrompeu:
oci: unbundle gzip: <archive error>: oci: published bundle cannot be unpacked (oci: descompactação gzip do bundle: o erro do arquivo: oci: o bundle publicado não pode ser descompactado)
um que para a meio de um ficheiro:
read <file> from the published bundle: <archive error>: oci: published bundle cannot be unpacked (leitura do ficheiro indicado a partir do bundle publicado: o erro do arquivo: oci: o bundle publicado não pode ser descompactado)
um documento que declara um tipo que nunca é publicado:
the published document declares kind <kind>, which a registry does not publish: oci: published artifact is not an entity document (o documento publicado declara um tipo que um registo não publica: oci: o artefacto publicado não é um documento de entidade)
e bytes que não são de todo um documento:
the published bytes do not parse as a document (<parse error>): oci: published artifact is not an entity document (os bytes publicados não são analisados como um documento, com o erro de análise: oci: o artefacto publicado não é um documento de entidade)
Como corrigir: um arquivo que não se descompacta tem de ser substituído pelo publicador. Os bytes publicados estão congelados, pelo que a solução é publicar a entidade de novo numa nova versão; quem a estiver a consumir deve comunicar a mensagem a quem a publica. Um documento que não é uma entidade significa quase sempre que a referência não é a pretendida: verificar que nomeia a coordenada em que uma entidade está publicada, que é a referência que aggrega push imprime quando publica uma.
The registry could not answer what is attached to an artifact (O registo não conseguiu responder ao que está anexado a um artefacto)
As assinaturas e outros anexos ficam pendurados num artefacto em vez de estarem dentro dele, e encontrá-los é uma pergunta feita ao registo. Esta condição diz que a pergunta ficou sem resposta — o registo não serve essa consulta, o artefacto de que os anexos estão pendurados não pôde ser localizado, ou o próprio pedido falhou.
Isso não é o mesmo que uma resposta «nada está anexado», e confundir as duas é exatamente o que isto existe para impedir. Um artefacto que realmente não traz nenhuma assinatura resolve-se normalmente e produz uma lista vazia. Isto diz que a lista nunca foi obtida, pelo que não se sabe absolutamente nada sobre o que está anexado.
A interrupção da compilação depende de ser exigida uma assinatura, e ambos os sentidos são deliberados:
É exigida uma assinatura. A compilação para. Uma verificação exigida que não pôde ser executada não foi aprovada, e admitir o artefacto assentaria numa pergunta que ninguém conseguiu fazer.
Não é exigida nenhuma assinatura. A compilação continua e di-lo em voz alta, em vez de em silêncio. A consulta não produziu nada a verificar num sentido ou noutro, pelo que recusar rejeitaria um artefacto com base numa pergunta sem resposta — mas o silêncio seria lido como um pull limpo sem assinatura, o que não é.
Mensagens emitidas. Um registo que não serve a consulta:
oci: target does not support referrer discovery: <target kind>: oci: referrer discovery could not be completed (oci: o destino não suporta a descoberta de referrers, com o tipo de destino indicado: oci: não foi possível concluir a descoberta de referrers)
o próprio artefacto não localizável:
oci: resolve subject "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci: resolução do sujeito indicado: a falha subjacente: oci: não foi possível concluir a descoberta de referrers)
e a consulta a falhar:
oci: list referrers of "<reference>": <the underlying failure>: oci: referrer discovery could not be completed (oci: listagem dos referrers da referência indicada: a falha subjacente: oci: não foi possível concluir a descoberta de referrers)
Quando não é exigida nenhuma assinatura, o mesmo texto aparece antes 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> (não foi possível executar a verificação da assinatura para o artefacto indicado (o registo não conseguiu responder à consulta de assinatura e não é exigida nenhuma assinatura; a continuar): a mensagem acima)
Como corrigir: a correção cabe ao operador e reside no registo e não no catálogo. Quando o registo não serve de todo consultas de anexos, não pode trazer assinaturas, pelo que se deve espelhar o artefacto para um registo que o possa fazer ou deixar de exigir assinaturas desse host em .aggrega-config.yaml — e tomar nota de qual das duas opções se escolhe, porque a segunda significa que as assinaturas desse host deixam de ser verificadas. Quando a consulta falhou num registo que a serve, trata-se de um problema de transporte ou de permissões especificamente no endpoint de anexos, e voltar a executar quando o registo estiver acessível é toda a solução.
An artifact that must be signed carries no signature (Um artefacto que tem de estar assinado não traz nenhuma assinatura)
É exigida uma assinatura para um artefacto quando a política de assinatura do próprio espaço de trabalho abrange o seu tipo ou quando o registo de onde provém está configurado para exigir uma. Esta condição comunica que o registo respondeu à consulta de anexos, que nada estava anexado e que era exigida uma assinatura.
Os dois requisitos são uma única postura lida em dois âmbitos. A política de todo o espaço de trabalho impõe uma assinatura a um tipo abrangido pelo seu âmbito mesmo a partir de um host cuja própria entrada não exige nenhuma, pelo que um host que não exige nada não isenta um artefacto abrangido pela política de todo o espaço de trabalho.
Quando não é exigida nenhuma assinatura, isto não é de todo uma falha. O artefacto é verificado se estiver presente uma assinatura e passa sem aviso se não houver nenhuma, e é isso que torna utilizável sem cerimónia um host sem uma postura configurada.
Um artefacto cujo tipo não pôde ser determinado enquanto está ativa uma política de todo o espaço de trabalho é tratado como se exigisse uma assinatura e não como isento, de modo que um artefacto não classificável não pode escapar a uma política que está ativada.
Mensagem emitida, enquadrada pela referência que estava a verificar:
verifying the signature of <uri>: signing: no signature found for an artifact that requires one (verificação da assinatura do artefacto indicado: signing: nenhuma assinatura encontrada para um artefacto que exige uma)
Como corrigir: a correção cabe ao operador ou ao publicador, não ao autor da entidade. Quando se esperava que o artefacto estivesse assinado, foi publicado sem assinatura — comunicar a referência a quem o publica, já que só quem o publica pode anexar uma. Quando o artefacto não se destina a ser assinado, o que há a mudar é o requisito: provém da entrada do registo em .aggrega-config.yaml ou da política de assinatura de todo o espaço de trabalho, e a referência da mensagem indica qual o host a examinar. Desativar um requisito significa que os artefactos desse host deixam de ser verificados, pelo que é preferível restringir o âmbito da política a um tipo em vez de a desativar por completo.
A signature does not verify (Uma assinatura não passa na verificação)
Foi encontrada e verificada uma assinatura, e a verificação falhou. É o resultado negativo geral dessa verificação, e abrange uma cadeia de certificados que não tem raiz no material de confiança, uma assinatura sem entrada no log de transparência quando é exigida uma, uma assinatura sobre um artefacto diferente daquele que se tem em mãos, um bundle que foi alterado e um bundle verificado contra uma chave fixada com a qual não passa na verificação.
É deliberadamente distinta de uma assinatura cujo signatário não é fidedigno. Essa é estruturalmente válida e feita pelo signatário errado; esta não passou de todo na verificação. Mantê-las separadas é o que permite distinguir «o artefacto não é o que foi assinado» de «o artefacto foi assinado por alguém que não foi aceite».
Para que artefacto foi feita uma assinatura é verificado duas vezes. Assim que a verificação criptográfica da assinatura se confirma, a cadeia de ferramentas lê na própria assinatura para que artefacto foi feita — a mesma leitura à qual cada compilação posterior submete a assinatura registada, que é o que permite a uma compilação recusar uma assinatura copiada de um artefacto para outro sem verificar nada — e recusa a assinatura quando essa leitura não nomeia o artefacto em mãos, ou quando a assinatura está numa forma da qual a leitura não consegue extrair o artefacto. São lidas as duas formas que um pull aceita: uma assinatura feita sobre o próprio artefacto e uma declaração assinada que o nomeia. A leitura segue as regras próprias da verificação criptográfica, pelo que, sobre uma assinatura que essa verificação aceita, as duas concordam; uma recusa deste tipo significa que não concordaram, e vale a pena comunicá-la com a referência e a mensagem em vez de a contornar através da configuração.
Quando a entrada de um registo marca a verificação como consultiva, o mesmo texto é comunicado como aviso e a execução continua.
Mensagens emitidas. Da própria verificação, citando o que o verificador comunicou:
signing: signature bundle does not verify: <what the verifier reported> (signing: o bundle de assinatura não passa na verificação: o que o verificador comunicou)
e, quando a verificação criptográfica se confirma e a leitura de para que artefacto foi feita a assinatura não concorda:
signing: signature bundle does not verify: its cryptographic check holds, but it does not name <manifest-digest> as the artifact it was made for (signing: o bundle de assinatura não passa na verificação: a sua verificação criptográfica confirma-se, mas não nomeia o digest do manifesto indicado como o artefacto para o qual foi feito)
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: o bundle de assinatura não passa na verificação: a sua verificação criptográfica confirma-se, mas está numa forma da qual não é possível ler o artefacto para o qual foi feito)
cada uma enquadrada pela referência que está a ser verificada:
verifying the signature of <uri>: <the message above> (verificação da assinatura do artefacto indicado: a mensagem acima)
e, quando a entrada do registo torna a verificação consultiva, como aviso em vez de interrupção:
signature verification failed for <uri> (advisory; continuing): <the message above> (a verificação da assinatura falhou para o artefacto indicado (consultiva; a continuar): a mensagem acima)
Como corrigir: nada nos ficheiros de entidade causa isto e nenhuma alteração de autoria o resolve. Tratá-lo como uma afirmação sobre o artefacto e não sobre a configuração: os bytes em mãos não são os bytes que foram assinados, ou a assinatura não é uma que o material de confiança configurado consiga verificar. Obter primeiro o artefacto de novo, já que uma cópia em cache truncada ou alterada falha exatamente desta forma e uma nova obtenção resolve-o. Quando o problema sobrevive a uma nova obtenção, comunicar a referência e as próprias palavras do verificador a quem publica o artefacto. Não recorrer à definição consultiva para o contornar — essa definição mantém a verificação em execução e impede-a de interromper a compilação, o que é uma escolha deliberada de aceitar artefactos não verificados desse host e não uma forma de corrigir um.
A signature verifies but its signer is not one the registry trusts (Uma assinatura passa na verificação, mas o seu signatário não é um em quem o registo confia)
A assinatura passou na verificação — a cadeia de certificados tem raiz no material de confiança e a entrada de transparência está presente — e a identidade nesse certificado não corresponde a nenhuma das identidades configuradas como aceitáveis para o registo. O artefacto foi assinado por um signatário real que não foi aceite.
São comparadas as duas metades de uma identidade, o sujeito e o emissor que respondeu por ele, e qualquer uma das duas pode ser a que não correspondeu. A mensagem nomeia ambas quando podem ser lidas do certificado, porque um signatário que apresenta um sujeito esperado sob um emissor que ninguém aceitou parece idêntico a um sujeito errado, a menos que sejam mostradas ambas.
Mensagens emitidas. Com as duas metades legíveis:
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: a identidade da assinatura não é fidedigna para este registo: o que o verificador comunicou; o signatário apresentou o emissor indicado com a identidade indicada, mas nenhuma identidade fidedigna permite esse emissor)
e, quando não podem ser lidas, recorrendo ao próprio relato do verificador:
signing: signature identity is not trusted for this registry: <what the verifier reported> (signing: a identidade da assinatura não é fidedigna para este registo: o que o verificador comunicou)
Como corrigir: esta é uma decisão do operador, e é uma decisão real e não uma formalidade. Comparar o emissor e a identidade da mensagem com as identidades fidedignas configuradas para esse registo em .aggrega-config.yaml. Quando o signatário é um que se pretende aceitar, adicioná-lo — uma entrada nomeia uma identidade, ou um padrão que corresponde a uma, juntamente com o emissor, e ambos têm de estar corretos. Quando não é, o artefacto foi assinado por alguém que não foi aceite, e adicionar a identidade para fazer passar a compilação é a única resposta a evitar. Os registos que anunciam a sua própria política de confiança podem tê-la fixada quando o registo é adicionado, que é a forma de incluir as identidades pretendidas sem as transcrever.
A keyless trust policy names no acceptable signer (Uma política de confiança sem chave não nomeia nenhum signatário aceitável)
A verificação sem chave decide se aceita um artefacto comparando a identidade no seu certificado de assinatura com um conjunto de identidades configuradas como aceitáveis. Um conjunto vazio é recusado em vez de ser tratado como uma política: comparar com nada aceitaria todos os signatários ou rejeitá-los-ia a todos, e nenhuma das duas coisas é o que pretendia um operador que configurou a verificação.
Mensagem emitida, que é a própria frase da condição:
signing: keyless verification requires at least one trusted identity (signing: a verificação sem chave exige pelo menos uma identidade fidedigna)
Como corrigir: configurar pelo menos uma identidade fidedigna para o registo em .aggrega-config.yaml. Uma entrada nomeia a identidade — como sujeito exato ou como padrão que corresponde a um — juntamente com o emissor que responde por ela, e ambos são obrigatórios. Quando o registo anuncia a sua própria política de confiança, fixar essa política quando o registo é adicionado preenche o conjunto com o que o registo publica. Quando não se pretende de todo verificar as assinaturas deste registo, trata-se de uma definição diferente de um conjunto de identidades vazio, e defini-la explicitamente é o que o declara.
The pinned trust root cannot be read (A raiz de confiança fixada não pode ser lida)
Uma raiz de confiança fixada no espaço de trabalho é o que permite a uma verificação sem chave verificar sem acesso à rede onde quer que seja executada: um ficheiro cujo conteúdo é o material contra o qual cada assinatura é verificada. Esta condição comunica que o ficheiro no caminho configurado não pôde ser transformado em material de confiança utilizável — está ausente, não é legível, ou o seu conteúdo não é uma raiz de confiança.
É interrompida em vez de recorrer a outra coisa. Uma raiz fixada é uma escolha deliberada de verificar as assinaturas contra material que se controla, pelo que obter uma silenciosamente em seu lugar substituiria essa escolha por outra e produziria um resultado de verificação que ninguém pediu.
Mensagem emitida, que nomeia o caminho e cita o que a leitura comunicou:
signing: cannot load pinned trust root: <path>: <what the read reported> (signing: não é possível carregar a raiz de confiança fixada: o caminho indicado: o que a leitura comunicou)
Como corrigir: isto cabe ao operador. Verificar que o caminho configurado para a raiz de confiança existe e pode ser lido por quem executa o comando — um caminho relativo a um diretório de trabalho diferente e um ficheiro presente mas ilegível são ambos comunicados aqui. Quando o ficheiro existe e pode ser lido, o seu conteúdo não é uma raiz de confiança, pelo que se deve substituí-lo por um bundle atual da fonte de onde foi obtido, em vez de o editar. Quando não se pretendia uma raiz fixada, o que há a mudar é a configuração: remover a fixação, e a verificação usa o material que lhe seria fornecido de outra forma.
A pinned verification key is not the key profile the verifier accepts (Uma chave de verificação fixada não é do perfil de chave que o verificador aceita)
Assinar e verificar com uma chave detida usam um único perfil de chave, e uma chave de qualquer outro tipo é recusada em vez de tentada. É uma afirmação sobre o tipo da chave, não sobre se ela verifica alguma coisa.
Os dois momentos em que é comunicada são tarefas diferentes. Um é carregar uma chave com a qual assinar, o que acontece onde um artefacto é publicado; o outro é verificar uma assinatura contra uma chave fixada para um registo, o que acontece onde um artefacto é verificado. A recusa é a mesma em ambos.
Mensagens emitidas, cada uma das quais nomeia o algoritmo da chave efetivamente fornecida — an RSA key ou an Ed25519 key. Uma chave de verificação fixada:
signing: unsupported held-key type: pinned key is <the key's algorithm>, want ECDSA P-256 (signing: tipo de chave detida não suportado: a chave fixada usa o algoritmo indicado, é esperada ECDSA P-256)
e uma chave carregada para assinar:
signing: unsupported held-key type: held key is <the key's algorithm>, want ECDSA P-256 (signing: tipo de chave detida não suportado: a chave detida usa o algoritmo indicado, é esperada ECDSA P-256)
Como corrigir: fornecer uma chave do perfil que a mensagem nomeia. Quando se está a verificar, a chave é a fixada para o registo em .aggrega-config.yaml, e tem de ser a metade pública da chave com a qual o publicador assina — uma divergência aqui significa geralmente que foi fixado o ficheiro errado, já que uma chave do tipo certo, mas que não é a chave certa, é antes comunicada como uma assinatura que não passa na verificação. Quando se está a assinar, gerar uma chave do perfil indicado, ou usar o caminho sem chave, que não precisa de nenhuma chave detida.
The workspace is offline and the step needs the network (O espaço de trabalho está offline e o passo precisa da rede)
Um espaço de trabalho pode ser marcado como offline, e essa definição é uma recusa e não uma preferência: cada passo que alcançaria a rede é recusado onde é construído, antes de ser aberta qualquer ligação. Recusar cedo é o que faz a falha dizer «este espaço de trabalho está offline» em vez de surgir mais tarde como um tempo limite esgotado sem explicação.
Uma única decisão, lida num único local. Um passo que precisa de saber de antemão se a rede poderia ser alcançada faz a mesma pergunta que a própria obtenção faz, pelo que uma verificação e a operação que ela protege não podem chegar a conclusões diferentes.
Abrange vários tipos de trabalho, todos com a mesma recusa: adquirir um artefacto de um registo, adquirir a fonte de uma Recipe através da rede, obter uma entrada externa, obter uma identidade com a qual assinar e obter material de confiança. Uma compilação que lê uma cache preenchida não alcança nenhum deles, e é esse o objetivo da definição.
Quando o comando inteiro é uma ida e volta pela rede, a recusa vem primeiro e não por último.push, push-artifact e registry update existem para alcançar um registo, pelo que o dizem antes de ler a entidade ou de percorrer os repositórios, e nomeiam qual dos três locais definiu o modo — a flag escrita, a variável de ambiente, ou o ficheiro e a chave dentro dele. Um --dry-run é a exceção, e é uma exceção pelo que faz e não pelo nome que tem: comunica o que publicaria e não chama nada, pelo que é a forma de uma publicação segura offline e continua a funcionar.
Mensagem emitida, que traz a sua própria correção e é a própria frase da condição:
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: acesso à rede recusado porque o espaço de trabalho está offline; correção: passar a flag que permite a rede para esta única execução, ou remover a chave de nível superior do modo offline no ficheiro de configuração (ou AGGREGA_OFFLINE) para a permitir a partir de agora; quando o trabalho é uma compilação que precisa de conteúdo que a máquina não tem, executar primeiro o pull da Release indicada a partir de um ambiente ligado para preencher a cache)
Enquadrada pelo que precisava da rede — a aquisição da fonte de uma Recipe, por exemplo:
sourceresolver: kind=<kind> url=<url> version=<version>: <the message above> (sourceresolver: com o tipo, o URL e a versão indicados: a mensagem acima)
Adicionar o hub oficial num espaço de trabalho offline não é recusado: o hub é adicionado com a sua base integrada, e o aviso diz que não foi pedida ao hub a sua política de confiança porque o espaço de trabalho está offline.
Como corrigir: a mensagem nomeia três caminhos, e cabe ao utilizador decidir qual se aplica. Quando o modo está definido e se pretende ultrapassá-lo para este único comando, passar --offline=false; é para isso que a flag existe, e é a única resposta disponível para quem não escreveu pessoalmente o ficheiro de configuração. Quando o espaço de trabalho se destina a estar offline, o que há a corrigir é o conteúdo em falta: executar o pull a partir de um local com acesso à rede para que a cache contenha tudo o que a Release alcança, e depois a compilação offline não precisa de mais nada. Quando não se destina de todo a estar offline, remover a definição na sua origem — a chave de nível superior offline em .aggrega-config.yaml, ou a variável de ambiente que a mensagem nomeia, e a variável é a que apanha as pessoas desprevenidas porque não está em nenhum ficheiro. Note-se que um espaço de trabalho offline não pode de todo assinar pelo caminho sem chave, já que emitir um certificado e registá-lo são operações de rede sem forma offline.
Ao construir a topologia
Quando cada Component tem uma Recipe resolvida, o compilador une os Components no grafo IR, lendo o bloco uses: de cada Component e cruzando os destinos e os anexos de funcionalidades.
Dangling uses target (Destino de aresta pendente)
Uma aresta uses: nomeia um componente de destino que não existe na topologia resolvida. A interrupção é agnóstica em relação à origem — uma aresta do Aggregate escrita pelo programador e uma aresta cablada por uma Release são detetadas da mesma forma. Um destino pendente é uma interrupção fatal, e não um descarte silencioso: uma aresta para um destino inexistente desapareceria de outro modo e deixaria silenciosamente vazios os valores injetados do consumidor no momento da implementação. É o irmão estrutural da interrupção por socket não declarado mais abaixo: seja qual for o socket em que uma ligação é cablada, o seu destino tem de se resolver num componente existente antes de o tipo da aresta ser verificado.
Mensagem emitida. Primeiro vem a recusa, depois o destino que não corresponde a nada e o socket em que a ligação foi cablada — depois o que fazer a esse respeito:
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. (o destino da aresta uses não existe: o destino indicado, cablado no socket indicado. Apontar o destino para um componente que o Aggregate declara, ou declarar um componente com esse nome.)
A constatação é posicionada na entrada escrita a que diz respeito, no documento em que essa entrada foi escrita, pelo que uma ligação traçada pelo próprio bloco uses: de um componente, uma projetada por um anexo e uma cablada por uma Release são comunicadas, cada uma, no seu próprio bloco. Cada ligação infratora é comunicada como uma constatação própria, pelo que uma única compilação as nomeia todas em vez de parar na primeira.
Como corrigir: declarar o componente de destino em falta, ou corrigir o nome do destino na entrada uses: para que corresponda a um componente existente.
Two connections of one component under one alias (Duas ligações de um componente sob um mesmo alias)
Um componente lê cada uma das suas ligações pelo seu alias — a chave sob a qual a ligação foi escrita ou, para uma ligação escrita como entrada de lista, o próprio nome do seu destino. Um modelo de Recipe lê as ligações de um componente indexadas apenas pelo alias, e uma asserção lê-as indexadas pelo socket e depois pelo alias, pelo que duas ligações de um componente sob um mesmo alias partilhariam um único slot em pelo menos uma dessas vistas: a posterior ocupá-lo-ia, e a outra estaria ausente do que o modelo ou a asserção vê. Assim, um alias nomeia uma única ligação de um componente — seja qual for o socket em que cada uma é cablada, o que quer que a tenha traçado (o próprio bloco uses: do componente, o bloco uses: de um anexo em qualquer âmbito ou uma entrada por aresta de uma Release) e seja qual for o seu destino. Um par interrompe a compilação assim que o grafo é definitivo, antes de qualquer asserção ser executada e antes de qualquer coisa ser renderizada.
O par surge de uma autoria que é legal em cada superfície isoladamente: a entrada própria de um componente e a de um anexo num mesmo socket e alias; uma lista que nomeia duas vezes o mesmo destino (models: [llama, llama]); um alias escrito em dois sockets (models: { local: … } ao lado de databases: { local: … }); dois anexos que cablam um mesmo alias; ou uma entrada de Release que traça uma ligação num socket que o Aggregate deixou sem associação, sob um alias que o Aggregate já usou noutro socket. Duas estruturas vizinhas nunca chegam a esta interrupção: uma chave escrita duas vezes num mesmo bloco de entradas com chave faz falhar o carregamento do documento, e uma entrada de Release num socket e num alias que outro bloco já traçou configura essa ligação — ou, se nomear um destino diferente, interrompe-se como uma mudança de destino — em vez de traçar uma segunda.
Mensagem emitida. Primeiro vem a recusa, depois o alias e o componente, depois o socket desta ligação, o seu destino e onde a sua entrada foi escrita, depois o mesmo para a ligação que já detém o alias — depois o que fazer a esse respeito:
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. (o alias de ligação já é usado por outra ligação do mesmo componente: o alias e o componente indicados, o socket, o destino, o ficheiro e o caminho de chaves desta ligação, depois os mesmos dados da ligação que já detém o alias. Dar a uma das duas ligações um alias próprio: um componente lê cada ligação pelo seu alias, seja qual for o socket em que está cablada. Uma entrada de lista toma o nome do seu destino como alias, pelo que um destino listado duas vezes é listado uma só vez, ou escrito como duas entradas com chave sob dois aliases.)
Onde as duas ligações foram escritas num mesmo caminho de chaves — uma lista que nomeia duas vezes o mesmo destino —, cada uma é também nomeada pela sua posição nessa lista, list entry "2" ao lado de list entry "1", que é a única coisa que distingue as duas entradas.
A constatação é posicionada na entrada própria da ligação posterior — a traçada em segundo lugar, que é a que de outro modo teria ocupado o slot do alias — no documento em que essa entrada foi escrita. Assim, uma entrada de Release, ou um anexo que a Release escreve, conta como um defeito de operações, e uma entrada no Aggregate como um defeito do programador. Cada ligação infratora é comunicada como uma constatação própria, pelo que uma única compilação as nomeia todas.
Algumas estruturas são nomeadas com menos exatidão. Um nome de anexo declarado em mais de um âmbito — num componente e no subsistema que o contém, por exemplo — traça uma ligação a partir de cada bloco que o declara, e a compilação regista ambas apenas sob o nome do anexo. As duas ligações são então nomeadas num dos blocos declarantes — o próprio bloco de anexos do componente, onde quer que o nome esteja aí declarado — e nenhuma delas tem uma posição de lista. O mesmo acontece dentro de um Aggregate importado, onde os blocos declarantes — o de um componente e o de um dos próprios subsistemas do módulo — são nomeados no próprio documento do módulo. Em cada uma destas estruturas o par continua a ser recusado.
Como corrigir: dar a uma das duas ligações um alias próprio. Para uma lista que nomeia duas vezes o mesmo destino, listar o destino uma só vez, ou escrever as duas ligações como entradas com chave sob dois aliases. Para um alias em dois sockets, mudar o nome de uma das duas chaves. Um anexo que cabla um socket sob um alias que o componente já usa recebe uma chave diferente no seu próprio bloco uses:.
uses: socket not declared in the owning entity’s usesSchema (Socket não declarado no esquema de sockets da entidade proprietária)
Um bloco uses: nomeia um socket que a entidade proprietária da superfície não declara no seu usesSchema, numa das duas superfícies onde só um socket declarado pode ser nomeado: o uses:de um anexo de Feature, onde o socket tem de ser declarado na Feature anexada, e o uses: por aresta de uma Release, onde tem de ser declarado no Component consumidor. Uma Release só pode cablar ou configurar arestas dentro dos sockets que o usesSchema do Component já declara.
A superfície dos anexos é verificada em cada âmbito em que um anexo é escrito: num componente, num subsistema — do Aggregate ou de um módulo que este importa —, numa fronteira de Release e numa entrada de componente da Release, incluindo a entrada de um componente que um módulo fornece. As declarações próprias de um módulo são verificadas assim que a composição que o importa é construída, e a constatação nomeia o Aggregate do módulo e a chave dentro do seu documento.
O bloco uses:próprio de um componente não é, deliberadamente, uma dessas superfícies, pelo que esta interrupção não é acionada para ele. Um programador é dono da topologia que o Aggregate declara e pode nomear um socket que o catálogo não declarou; o silêncio do catálogo sobre um socket significa que a ligação não foi prevista, e não que seja proibida. Esse socket é legal e a sua aresta é construída — aquilo de que abdica é o seletor e o contrato por aresta que um socket declarado traz. Um nome de socket mal escrito nesse ponto não é, portanto, uma interrupção, mas uma ligação ad hoc própria, e é comunicado como um aviso que nomeia as duas grafias — ver warnings.md «Uses-socket near-miss lint (Lint de quase correspondência de sockets uses)».
Mensagem emitida:
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 desconhecido: nomear um socket que a entidade declara no seu usesSchema — só o próprio bloco uses de um componente pode nomear um que o catálogo não declarou; com a Release, a entrada do componente, o tipo de componente, o nome do socket e os sockets declarados)
O ramo dos anexos nomeia o tipo de funcionalidade em vez do tipo de componente; uma Feature anexada que não declara nenhum usesSchema comunica, em vez disso, que as declarações uses: não são permitidas para ela.
Como corrigir: num anexo, corrigir o nome do socket para um que a Feature anexada declara, ou declarar esse socket no usesSchema da Feature. Numa entrada por aresta de uma Release, corrigir o nome do socket para um que o Component consumidor declara — uma Release não pode introduzir um socket que o Component não declara, e mover a declaração para a entidade do catálogo é o caminho suportado. Se a entidade do catálogo não declarar nenhum usesSchema, não aceita declarações uses: nessa superfície — remover o bloco.
A connection carries an attachment under a name its socket declares no slot for (Uma ligação traz um anexo sob um nome para o qual o seu socket não declara nenhum slot)
O bloco features: de uma entrada de ligação nomeia um anexo que nenhum slot do socket da ligação declara. Os anexos que uma ligação traz são um conjunto fechado: o socket pelo qual a ligação é cablada declara, num featuresSchema na entrada do usesSchema do Component consumidor, cada slot que uma ligação nesse socket pode preencher, e um anexo sob qualquer outro nome é recusado quando a compilação é carregada. Um socket que não declara nenhum featuresSchema não admite anexos nas suas ligações, e o mesmo acontece com um socket que o Aggregate nomeia sem que o Component o declare — esse socket não declara nenhum slot.
A regra aplica-se aos dois documentos que escrevem os anexos de uma ligação: a entrada de ligação do Aggregate sob o uses: de um componente e a entrada uses: por aresta da Release. Para um componente que um subagregado fornece, os nomes do programador são verificados assim que o próprio documento do subagregado é lido, e a constatação nomeia o ficheiro desse documento e a entrada do componente nele. Os nomes da Release são verificados assim que a composição é achatada, para cada componente sobre o qual a Release escreve, e a constatação nomeia a própria entrada da Release — dentro da fronteira em que se encontra, ou sob a entrada de encaminhamento que alcança o componente de um subagregado. Uma entrada de Release num socket que o Component não declara é comunicada pela interrupção por socket não declarado mais acima, que lista os sockets que de facto existem, e não por esta.
Mensagem emitida. Primeiro vem a recusa, depois o documento e a entrada, o nome do anexo, a ligação, o socket, o componente e os slots que o socket declara — depois o que fazer a esse respeito:
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. (uma ligação traz um anexo sob um nome para o qual o seu socket não declara nenhum slot: o Aggregate, a entrada, o anexo, a ligação, o socket e o componente indicados, com os slots que o socket declara. Escrever o anexo sob um dos slots que o socket declara, ou declarar este slot no featuresSchema do socket no Component.)
Onde o nome está a uma edição de distância de um slot que o socket declara — um carácter transposto, omitido, duplicado ou errado, a estrutura que uma gralha assume —, esse slot é nomeado logo a seguir, de modo que a grafia provavelmente pretendida está na mesma 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>", …) (uma ligação traz um anexo sob um nome para o qual o seu socket não declara nenhum slot: a Release e a entrada indicadas, o nome do anexo próximo do slot declarado, a ligação indicada, …)
Não é levantado nenhum aviso separado para um nome assim. No próprio bloco features: de um componente, um nome a uma edição de distância de um slot declarado é legal e dá origem apenas ao aviso descrito em «An attachment name is one edit from a declared slot (Um nome de anexo está a uma edição de distância de um slot declarado)» mais abaixo; numa ligação o nome é recusado, e a recusa traz o próprio emparelhamento.
Onde o socket não declara nenhum slot, a lista não aparece e a recomendação diz «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. (O socket não declara nenhum slot, pelo que nenhuma ligação cablada através dele traz um anexo: remover o anexo, ou declarar o slot no featuresSchema do socket no Component.)» Onde o Component não declara de todo o socket, diz «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. (O tipo do componente não declara este socket, pelo que o socket não declara nenhum slot e nenhuma ligação cablada através dele traz um anexo: remover o anexo, ou declarar o socket e o seu slot no usesSchema do Component.)»
Cada anexo infrator é comunicado como uma constatação própria, pelo que uma única compilação os nomeia todos.
Como corrigir: escrever o anexo sob um slot que o socket declara; ou, se a ligação precisar de um slot que o socket não tem, declará-lo no featuresSchema do socket no Component. Num socket que o Component não declara, declarar o socket e o seu slot no usesSchema do Component, ou remover o anexo.
Release retargets a developer-declared edge (A Release muda o destino de uma aresta declarada pelo programador)
Uma entrada uses: por aresta de uma Release nomeia um destino diferente daquele que o programador já cablou para o mesmo socket e alias. Uma Release pode configurar uma aresta que o programador declarou (definir infra por aresta, nomeando o mesmo destino ou omitindo-o) e pode cablar uma aresta num socket declarado mas sem associação, mas não pode mudar o destino de uma aresta que o programador declarou — o programador é dono da arquitetura que escreveu.
Os dois destinos são comparados tal como foram escritos, e não tal como se resolvem. Um target: pode nomear o alias publicado de um subagregado em vez de um id de componente, e esse alias resolve-se no componente para o qual o módulo o publica — pelo que uma entrada de Release que repete exatamente o alias que o programador escreveu é uma configuração e é aceite, tal como a repetição de um simples id de componente.
A aresta mantém o destino que o programador lhe deu, quer esta interrupção seja acionada, quer não, e o bloco infra: da entrada de Release não lhe é aplicado. Uma mudança de destino recusada nunca é aplicada pela metade.
Mensagem emitida. Primeiro vem a recusa, depois o destino que o programador declarou, o destino que a Release nomeou e o socket — depois o que fazer a esse respeito:
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. (a aresta da Release muda o destino de uma aresta declarada pelo programador: o destino declarado, o destino que a Release nomeia e o socket em que está cablada, indicados. Retirar o destino da entrada da Release para configurar a ligação tal como foi declarada, ou mudar o destino onde a ligação é declarada.)
A constatação é posicionada na entrada escrita em que a ligação foi declarada, no documento que a declarou. Cada entrada infratora é comunicada como uma constatação própria, pelo que uma única compilação as nomeia todas em vez de uma por execução.
Como corrigir: retirar o target divergente da entrada uses: da Release para configurar a aresta existente (apenas infra por aresta), ou, se a ligação pertencer de facto a outro socket, cablá-la através de um socket que o programador deixou sem associação. Para mudar o próprio destino, mudá-lo no Aggregate, onde a topologia é escrita.
Release per-edge configuration has no edge to apply to (A configuração por aresta da Release não tem nenhuma aresta à qual se aplicar)
Uma entrada uses: por aresta de uma Release define infra:, anexos sob features:, ou ambos, mas não existe nenhuma aresta no consumidor, no socket e no alias que nomeia, depois de traçadas todas as arestas da compilação.
As duas coisas que uma entrada de Release pode fazer são cablar uma aresta e configurar uma, e qual delas faz é decidido por nomear ou não um target:. Uma entrada com um destino cria a aresta que configura. Uma entrada sem destino configura uma aresta que já tem de existir — declarada pelo programador no Aggregate, ou fornecida por uma Feature anexada. Assim, uma entrada que não nomeia nenhum destino e não corresponde a nenhuma aresta existente não se aplica a nada: o bloco infra: e os anexos abaixo dele nunca chegam a nenhuma saída. A compilação para em vez de aceitar uma autoria que não faz nada, porque, de outro modo, uma compilação bem-sucedida seria lida como confirmação de que a infraestrutura foi aplicada e de que a ligação traz o que a entrada lhe colocou.
O alias faz parte do que uma entrada nomeia, pelo que uma entrada que configura um alias que o programador nunca declarou não alcança nenhuma aresta, mesmo quando o socket está associado sob outro alias. O mesmo acontece com uma entrada que nomeia um componente que o Aggregate não declara.
Duas condições vizinhas são comunicadas pelas suas próprias interrupções, e não por esta, porque cada uma tem mais a dizer. Um socket que o usesSchema do Component consumidor não declara é comunicado como socket não declarado, o que permite listar os sockets que de facto existem. Um target: que não nomeia nenhum componente é comunicado como destino pendente. Um componente desligado por um interruptor active: leva consigo as suas arestas, por conceção, pelo que uma entrada que ficou sobre ele é aceite em vez de interrompida.
Cada entrada infratora é comunicada. Uma Release com várias entradas que não alcançam nenhuma aresta é interrompida com uma destas mensagens por entrada numa única compilação, pela ordem em que o documento as declara, em vez de comunicar a primeira e deixar as restantes para a compilação seguinte.
Mensagem emitida, onde a entrada nomeia um componente que existe. Traz o caminho da própria entrada, pelo que é nomeada a linha a editar, e não o componente que a contém:
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. (a configuração por aresta da Release não tem nenhuma aresta à qual se aplicar: a Release, a entrada, o consumidor, o socket e o alias indicados. Dar um destino à entrada para cablar a aresta, ou removê-la: uma entrada sem destino configura uma aresta que já tem de existir.)
Uma Release que nomeia os seus componentes no nível superior em vez de sob fronteiras traz a estrutura que o seu autor escreveu — .spec.components.<consumer>.uses.<socket>.<alias> — e um componente nomeado dentro de uma entrada de encaminhamento aggregates: é nomeado através dessa entrada, sob o nome local que aí tem.
Onde a entrada nomeia um componente que o Aggregate não declara, a interrupção vem de uma fase anterior da compilação e diz o seguinte, nomeando o que a entrada define — infra, features ou infra and features:
release per-edge configuration has no edge to apply to: release edge <consumer>/<socket>/<alias> sets <infra|features|infra and features> on <consumer>, which is not a component in the topology (a configuração por aresta da Release não tem nenhuma aresta à qual se aplicar: a aresta da Release indicada define os blocos indicados no consumidor indicado, que não é um componente na topologia)
Como corrigir: acrescentar um target: à entrada, o que cabla a aresta e lhe aplica a configuração; corrigir o alias para aquele que o Aggregate declarou para essa ligação, de modo que a entrada configure a aresta existente; corrigir o nome do componente para um que o Aggregate declara; ou remover a entrada se a configuração já não for pretendida.
A Release attachment takes the name of a connection’s attachment (Um anexo da Release toma o nome do anexo de uma ligação)
Uma Release escreve um anexo sob o nome que um anexo numa das ligações de um componente toma: o alias da ligação, um ponto e o slot que o anexo preenche — gpt.credential para o anexo que preenche o slot credential na ligação gpt. O anexo de uma ligação é escrito na sua entrada de ligação — a ligação do Aggregate sob o uses: do componente, ou a entrada uses: por aresta da Release para a mesma ligação — e torna-se um anexo do componente consumidor sob esse nome composto. A Release escreve anexos em dois outros âmbitos cujas chaves podem conter um ponto, pelo que o nome composto também pode ser escrito aí:
O próprio bloco features: de uma entrada de componente, que se anexa a esse componente.
O próprio bloco features: de uma fronteira, que se anexa a cada componente colocado nessa fronteira ou numa fronteira aninhada dentro dela — incluindo os componentes de um subagregado que a fronteira encaminha para dentro sem os nomear. Uma chave aí é interrompida quando é igual ao nome composto em qualquer componente que alcança, quer nomeie um type:, quer não.
A compilação para em vez de incorporar qualquer um dos dois no anexo da ligação, porque então nenhum dos dois documentos mostraria na íntegra o que a compilação faz com ele. O slot de um socket é preenchido por ligação, pela própria entrada da ligação, e nunca por um anexo que caia em cascata sobre ele a partir de um âmbito mais amplo. Uma chave com ponto que nenhum anexo de ligação dos componentes que alcança toma é um nome de anexo comum, e não é recusada.
A verificação abrange um anexo que qualquer um dos dois documentos colocou na ligação, e tanto um componente que um subagregado fornece como um que o Aggregate declara.
Mensagem emitida, para uma chave numa entrada de componente. Primeiro vem a recusa, depois a Release e a entrada de componente, a chave que a Release escreveu, o componente, a ligação, o socket e o slot — depois a entrada de ligação onde a escrever:
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. (um anexo da Release toma o nome de um anexo que uma das ligações de um componente traz: a Release, a entrada do componente, a chave, o componente, a ligação, o socket e o slot indicados. Escrevê-lo na entrada de ligação, sob o caminho indicado, e remover a chave das features desta entrada: um anexo que uma ligação traz é escrito nessa ligação e em mais nenhum lugar.)
Mensagem emitida, para uma chave numa fronteira. Nomeia o bloco de anexos da fronteira e o componente cuja ligação traz o anexo:
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. (um anexo da Release toma o nome de um anexo que uma das ligações de um componente traz: a Release, o bloco de anexos da fronteira, a chave, o componente, a ligação, o socket e o slot indicados. Escrevê-lo na entrada de ligação do componente indicado, sob o caminho indicado, e remover a chave das features desta fronteira: um anexo que uma ligação traz é escrito nessa ligação e em mais nenhum lugar.)
Uma chave numa fronteira que alcança vários componentes cujas ligações trazem o nome composto é comunicada uma vez para cada um deles, porque cada ligação é uma edição separada.
A constatação é posicionada no bloco em que a chave foi escrita — a entrada de componente, ou o features: da fronteira — porque a própria chave contém um ponto e uma posição não consegue endereçar uma chave assim; em vez disso, a chave é nomeada na mensagem. Numa Release que nomeia fronteiras, uma entrada de componente lê-se .spec.boundaries.<boundary>.components.<component>, um componente nomeado dentro de uma entrada de encaminhamento aggregates: é nomeado através dessa entrada, sob o nome local que aí tem, e o bloco de uma fronteira aninhada lê-se .spec.boundaries.<outer>.boundaries.<inner>.features.
Como corrigir: mover o anexo para a entrada da Release para essa ligação — uses.<socket>.<alias>.features.<slot> sob o componente — escrevendo aí apenas infra: para dimensionar um anexo que o Aggregate declara, ou type: e infra: para um que só a Release cria; depois, remover a chave com ponto do features: do componente ou da fronteira. Uma chave válida para toda a fronteira e destinada às ligações de vários componentes é escrita uma vez em cada uma dessas ligações.
A Release connection attachment names no Feature type (Um anexo de ligação da Release não nomeia nenhum tipo de Feature)
Uma entrada uses: por aresta de uma Release coloca um anexo numa ligação, sob um slot para o qual o Aggregate não declara nenhum anexo nessa ligação, e não nomeia nenhum type:. Um anexo que uma Release escreve numa ligação é uma de duas coisas. Ou dimensiona um anexo que o Aggregate já declara na mesma ligação, e não nomeia nenhum tipo porque a declaração do Aggregate o nomeia; ou é um anexo que só a Release cria, e então a entrada da Release é o único lugar de onde pode vir o seu tipo de Feature. Sem um tipo, nada consegue escolher uma FeatureRecipe para o anexo.
A verificação abrange tanto um componente que um subagregado fornece como um que o Aggregate declara. Um componente que um interruptor active: desligou leva consigo as suas ligações, pelo que uma entrada que ficou sobre ele não é verificada.
Mensagem emitida. Primeiro vem a recusa, depois a Release e a entrada de ligação, o slot, a ligação, o socket e o componente — depois o que fazer a esse respeito:
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. (um anexo de ligação da Release não nomeia nenhum tipo de Feature, e o tipo é obrigatório para um anexo que só a Release cria: a Release, a entrada de ligação, o slot, a ligação, o socket e o componente indicados. Nomear, pelo seu tipo, a Feature que este anexo anexa, ou declarar o anexo na entrada de ligação do Aggregate e dimensioná-lo aqui.)
Cada anexo infrator é comunicado como uma constatação própria, pelo que uma única compilação os nomeia todos.
Como corrigir: acrescentar um type: que nomeie a Feature que o anexo anexa; ou, onde declarar o anexo cabe ao programador, declará-lo na entrada de ligação do Aggregate com os seus values: e manter apenas infra: na entrada da Release.
Component identity cannot be stamped on what it emits (A identidade do Component não pode ser carimbada no que ele emite)
A identidade de um componente não é apenas uma chave no seu Aggregate — é um nome dentro do cluster. Cada recurso que um componente emite é carimbado com ela, sob aggrega.ai/component-id e app.kubernetes.io/name, e os sintetizadores de cargas de trabalho nomeiam o que emitem a partir dela. Assim, a identidade tem de ser um nome que o destino aceite, e tem de ser um nome que significa o que diz.
Um nome que escreveu chega à saída exatamente como o escreveu, e é isso que faz do nome no seu Aggregate o nome que pode procurar no seu cluster. Vale a pena tê-lo, e é por isso que uma identidade que o destino recusaria é comunicada aqui em vez de ser reparada em silêncio em algo que nunca escreveu.
Um carácter é a exceção, e é um que não pode escrever: o ponto que une o nome de um módulo ao nome de um componente dentro dele. É excluído de todo o nome que escreve precisamente para que essa união seja inequívoca, e é retirado da identidade antes de esta ser carimbada — data-layer.main-db é carimbado como data-layer-zdmain-db. Isso não custa nenhum nome que alguém tenha escrito, e é o que permite carimbar um componente que um Aggregate importado fornece: um ponto não é um carácter que um nome de Service aceite, e dentro de um endereço do cluster separa um serviço do seu namespace, pelo que um nome com ponto entregue a um consumidor como host se resolveria noutro serviço em vez de falhar.
São recusadas duas estruturas.
Uma identidade que o alfabeto de carimbo não consegue levar. A identidade é escrita no valor do rótulo que cada recurso emitido traz, e esse alfabeto admite letras, dígitos, -, _ e ., e exige que o valor comece e termine com uma letra ou um dígito. As regras dos nomes escritos são próximas disto, mas não iguais — permitem que um nome comece ou termine com - ou _ —, pelo que _api e api- são ambos nomes que pode escrever e nenhum dos dois pode ser carimbado.
O comprimento que um nome pode ter não é perguntado aqui. Isso cabe ao destino em que um componente é implementado, e destinos diferentes respondem de formas diferentes: esta condição abrange as estruturas que nenhum destino conseguiria levar. Um nome recusado pelo seu comprimento é comunicado, em vez disso, pela própria recusa do destino, que traz o motivo desse destino e o comprimento que aceitaria.
Uma identidade que começa como começa uma identidade composta. Os recursos que uma Feature emite não podem ser carimbados com um nome de componente que tenha escrito, pelo que o Aggrega compõe para eles uma identidade a partir das partes que escreveu, atrás de um prefixo fixo que diz onde a Feature foi anexada. Onde a Feature está anexada a um único componente, a identidade é composta a partir desse componente e da chave sob a qual a Feature está anexada, e começa por cfr--. Onde está anexada a uma fronteira inteira, não se aplica o nome de nenhum componente, pelo que a identidade é composta a partir do caminho da fronteira e do nome sob o qual a Feature está anexada, e começa por bfr--. É o prefixo que diz ao leitor de qual das duas um recurso veio, em vez de ter vindo de um componente. Assim, bfr-- e cfr-- estão ambos reservados no início de uma identidade de componente. Um componente chamado bfr--api ou cfr--api seria carimbado de forma idêntica a um composto, e nada na saída emitida conseguiria distinguir os dois. Só o prefixo completo está reservado: um componente chamado bfr, cfr, bfr-api ou bfrontend tem um nome comum e a compilação é concluída.
A verificação lê a identidade que um componente de facto traz, que, para um componente fornecido por um Aggregate importado, é a qualificada — o nome do módulo, um ponto e o nome próprio do componente. Assim, dois nomes aceitáveis cada um por si podem ainda assim unir-se numa identidade que não o é: um módulo chamado bfr--x e um componente chamado y dentro dele unem-se em bfr--x.y, que começa como começa uma identidade composta. A interrupção nomeia a identidade unida, apontando para a chave que escreveu.
Mensagem emitida, para uma identidade que o destino recusaria:
component identity cannot be the name its emitted resources are stamped with: rename the component (Aggregate, at <field-path>, "<identity>", which must "<rule>") (a identidade do componente não pode ser o nome carimbado nos recursos que emite: mudar o nome do componente; com o Aggregate, o caminho do campo e a identidade indicados, e a regra que a identidade tem de cumprir)
e para uma que começa como começa uma identidade composta, onde <opening> é aquele dos prefixos reservados a que o nome correspondeu:
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>") (a identidade do componente não pode ser o nome carimbado nos recursos que emite: mudar o nome do componente; com o Aggregate, o caminho do campo e a identidade indicados, que não pode começar pelo prefixo reservado indicado)
Como corrigir: mudar o nome do componente, em cada superfície que o nomeia — o Aggregate que o declara e a Release que o coloca e o configura. Dar-lhe um nome que comece e termine com uma letra ou um dígito e que não comece nem por bfr-- nem por cfr--. Mudar o nome de um componente muda o nome que os seus recursos trazem no cluster, pelo que, numa aplicação já implementada, deve ser tratado como qualquer outra mudança de nome de um recurso.
The target will not accept a name derived from an authored identity (O destino não aceita um nome derivado de uma identidade escrita)
Cada destino deriva os seus próprios nomes da identidade de um componente: um instalador de charts deriva um nome de release, um orquestrador de contentores deriva nomes de serviço. Esta interrupção é esse destino a indicar que não pode usar um deles.
A Aggrega não detém as regras de nomeação de nenhum destino. Não sabe que comprimento um nome pode ter, que caracteres um destino admite nem o que a gramática de um destino exige no início de um nome — e deliberadamente não o sabe, porque isso varia consoante o destino, o tipo de recurso em que um nome acaba e, por vezes, um serviço dentro de um mesmo fornecedor. Por isso, antes de um nome ser definido, o compilador pergunta ao fornecedor que irá renderizar o componente, e esta interrupção comunica a resposta do fornecedor. É por isso que a mensagem contém a palavra do próprio destino para o que recusou (release name, Service name) e o motivo do próprio destino, em vez de uma regra escrita no compilador.
Porque é que o nome é recusado em vez de encurtado. Um nome que escreveu é o nome com que o seu workload é implementado: encurtá-lo mudaria o nome de cada recurso em cada saída existente, e fá-lo-ia em seu nome sem que o tivesse pedido. A pessoa que pode escolher um nome diferente é a pessoa que escreveu este, pelo que a interrupção aponta para a chave spec.components que escreveu e deixa o nome como está. Os nomes que a própria Aggrega compõe — a identidade de uma Feature anexada a uma fronteira inteira, por exemplo — são, pelo contrário, encurtados, porque são montados a partir de partes escritas em vários documentos e nenhum autor, sozinho, consegue ver o comprimento que atingem.
Duas respostas que um destino pode dar, e levam a sítios diferentes. Onde um nome mais curto seria aceite, a interrupção indica o comprimento que funcionaria, de modo que um novo nome é escolhido uma vez em vez de duas. Onde nenhum comprimento ajudaria — um carácter que a gramática do destino recusa na posição em que foi parar —, não é indicado nenhum comprimento, porque encurtar não o consegue resolver. O caso mais comum do segundo tipo: um destino cujos nomes só admitem minúsculas faz o escape de cada carácter que não admite, e cada escape começa com um hífen, pelo que um nome cujo primeiro carácter sofre escape produz um nome que começa com um hífen. Um destino que exige aí uma letra minúscula ou um dígito recusa-o, por mais curto que seja o resto. Um destino pode também sujeitar o início de um nome à regra mais estrita dos recursos a que dá nome: o destino helm recusa um nome que começa com um dígito, comunicado como Service name, porque o Helm aceita um nome de release assim, enquanto o cluster recusa um Service do Kubernetes com esse nome.
Uma terceira forma aparece apenas para um nome composto: um destino pode indicar um comprimento menor do que a identidade mais curta que o compilador consegue compor a partir das partes que recebeu, uma vez que uma identidade composta reserva espaço para um discriminador. A interrupção di-lo e nomeia a solução — encurtar as partes escritas — em vez de comunicar o fornecedor como defeituoso.
Alguns nomes existem apenas para a carga de trabalho que um componente renderiza. O fornecedor é consultado assim que o Workload desse componente é resolvido, e a consulta inclui o form do Workload e as suas chaves de Service, para que um destino possa avaliar também os nomes que constrói a partir deles. Com o destino helm, isso acrescenta dois: um CronJob name, com 52 caracteres no máximo e avaliado apenas para um Workload scheduled, porque o cluster nomeia o Job de cada execução a partir do CronJob, com um sufixo acrescentado; e cada Service name, <release name>-<service key>, com 63 caracteres no máximo. Um nome de Service é construído a partir de partes de dois autores — o nome do componente e a chave que a carga de trabalho declara, na Recipe ou numa FeatureRecipe —, pelo que o seu motivo indica a chave e o local onde a carga de trabalho a declara, spec.workload.services.<key>, ao lado do campo escrito. Uma chave suficientemente longa para não deixar espaço para nenhum nome de componente não indica nenhum comprimento dentro do qual escolher, e o motivo diz que é a chave que tem de ser mais curta. Estes nomes não são avaliados para uma Feature anexada a uma fronteira inteira: a sua identidade é fixada antes de o seu Workload ser resolvido, porque o local onde a sua saída é montada pode depender dela.
Mensagem emitida, para uma identidade 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 (o destino não aceita um nome derivado da identidade escrita deste componente: mudar o nome do componente (o componente indicado, escrito no caminho indicado, que o destino não pode usar como o tipo de nome indicado, com o motivo do destino). escolher um nome que o destino aceite, com no máximo o número de caracteres indicado)
Como corrigir: mudar o nome do componente para um que o destino aceite, em cada superfície que o nomeia — o Aggregate que o declara e a Release que o posiciona e configura. Onde a mensagem indica um comprimento, ficar dentro dele. Onde não indica, ler o motivo do destino: normalmente é um carácter que o destino não admite, e na maioria das vezes uma letra maiúscula no início do nome — ou, com o destino helm, um dígito nessa posição. Preferir letras minúsculas e dígitos com hífenes entre as palavras; o capítulo sobre nomeação explica o que custa um nome em cada tipo de destino. Onde o motivo indica uma chave de Service, o comprimento também pode ser recuperado encurtando essa chave no local onde a carga de trabalho a declara — e, onde o motivo diz que a chave não deixa espaço, só isso resolverá. Mudar o nome de um componente altera o nome que os seus recursos têm, pelo que, numa aplicação já implementada, deve ser tratado como qualquer outra mudança de nome de recursos.
Onde a identidade é uma que o compilador compôs e não uma que escreveu, a mesma interrupção comunica o valor composto e pede que encurte as partes a partir das quais foi construída — o nome sob o qual anexou uma Feature e o caminho da fronteira a que a anexou.
A provider never accepted a name the compiler composed (Um fornecedor nunca aceitou um nome composto pelo compilador)
Esta comunica um defeito num plugin, e não em algo que tenha escrito.
Definir um nome composto é uma troca: o compilador propõe uma identidade, o fornecedor aceita-a ou diz quão curta teria de ser, o compilador compõe uma mais curta e o fornecedor é consultado de novo. Uma segunda recusa é normal e esperada — encurtar para um comprimento pode deixar um carácter onde a gramática desse destino não o admite, e o fornecedor dizê-lo é a forma como um compilador que não conhece a gramática de nenhum destino e um fornecedor que a conhece chegam a acordo.
O que não é normal é um fornecedor que nunca aceita nada: um que indica um comprimento, recebe um nome desse comprimento e volta a recusá-lo. A troca é limitada e, ao atingir o limite, a compilação para e nomeia o fornecedor em vez de usar um nome com o qual o fornecedor nunca concordou. Um nome definido por desistência seria aposto em recursos reais sem que nada na saída registasse que não se chegou a acordo, e a consequência surgiria no momento da aplicação em vez de na compilação que o produziu.
Mensagem emitida:
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 (o guest do fornecedor nunca aceitou uma identidade de componente que o compilador compôs para ele (o guest do fornecedor indicado recusou o número de propostas indicado, sendo a última a identidade indicada). comunicar o defeito a quem mantém esse plugin de fornecedor)
Como corrigir: comunicá-lo a quem mantém o plugin de fornecedor nomeado, citando a última proposta da mensagem. Não existe nenhuma alteração de autoria que o contorne: o compilador já ofereceu cada comprimento que o fornecedor pediu. Se o fornecedor for um que mantém, a verificação a fazer é que um nome cortado para um limite que ele indica seja um nome que ele depois aceita.
Required uses: socket not populated (Socket obrigatório não preenchido)
Um Component declara no seu usesSchema um socket marcado com required: true, e nada na compilação cabla uma ligação nesse socket para uma das instâncias desse Component.
Três superfícies podem cablá-lo, e a interrupção só é acionada quando as três estão vazias. O próprio bloco uses: da instância no Aggregate; uma entrada uses: por aresta de uma Release que nomeia um target:, a qual cria a ligação num socket declarado mas sem associação; e o conjunto de ligações que a composição produziu, que é o que responde por um componente fornecido por um Aggregate importado — o bloco uses: de um componente assim encontra-se no próprio documento desse Aggregate, lido apenas quando a composição está montada. Como a terceira superfície é a última a ficar completa, a verificação é executada assim que a composição inteira existe, e não enquanto os dois documentos escritos são lidos, e faz a mesma pergunta a cada componente, seja qual for o documento que o declarou.
Duas estruturas que parecem dever preencher o socket não o fazem. Uma entrada de Release que não nomeia nenhum target: configura uma ligação que já tem de existir em vez de criar uma, pelo que não cabla nada (e, onde contém infra:, é comunicada pela sua própria interrupção mais acima). E o uses: de um anexo de Feature nomeia sockets declarados na Feature anexada, um conjunto de sockets separado numa entidade separada, pelo que um anexo nunca pode preencher um socket próprio de um Component.
Mensagem emitida:
required uses socket not populated (Component, at .spec.components.<instance>.uses.<socket>, "<socket-name>", declared required by component type "<component-type>") (socket uses obrigatório não preenchido (Component, no caminho do socket, com o nome do socket, declarado obrigatório pelo tipo de componente indicado))
A constatação é posicionada na entrada de socket que o autor tem de escrever, .spec.components.<instance>.uses.<socket>. O nome de instância que contém é o nome que o componente tem no documento que o declara, pelo que, para um componente fornecido por um Aggregate importado, o localizador nomeia uma chave que o próprio ficheiro desse Aggregate contém, e não o nome com prefixo que a composição lhe deu.
Cada socket obrigatório não preenchido é comunicado, em cada componente: uma única compilação informa sobre todos em vez de apenas sobre o primeiro.
Como corrigir: adicionar uma entrada uses: para o socket obrigatório, cablando-a a um destino que o selector: do socket aceite; ou cablá-lo a partir da Release com uma entrada que nomeie um target:. Se o socket já não dever ser obrigatório, atualizar o usesSchema do Component para definir required: false ou remover a declaração required.
Sub-aggregate nesting depth exceeded (Profundidade de aninhamento de subagregados excedida)
Uma cadeia de importações de subagregados excede a profundidade máxima de aninhamento do compilador. O limite impede um achatamento descontrolado de topologias profundamente aninhadas e obriga a uma decomposição arquitetural acima de um limiar.
Mensagem emitida:
max sub-aggregate nesting depth exceeded: depth <depth> at prefix <flattened-prefix>. (profundidade máxima de aninhamento de subagregados excedida: a profundidade indicada no prefixo achatado indicado.)
Como corrigir: reestruturar a topologia do agregado para reduzir o aninhamento. Um aninhamento tão profundo indica normalmente que a forma do Aggregate reflete a hierarquia organizacional em vez da topologia de implementação — considerar achatar grupos de subagregados em subsistemas do mesmo nível dentro de um único Aggregate pai.
Feature type mismatch between Aggregate and Release (Divergência de tipo de Feature entre Aggregate e Release)
O Aggregate e a Release anexam ambos uma funcionalidade com o mesmo nome de instância, mas cada um declara um type: diferente, e o anexo da Release alcança o componente a partir dos features: de uma fronteira. Onde a Release o escreve, em vez disso, na sua própria entrada para o componente, o mesmo conflito é recusado mais cedo e comunicado como E0153, em «A feature attached by both the Aggregate and the Release cannot be merged (Uma funcionalidade anexada tanto pelo Aggregate como pela Release não pode ser fundida)» mais acima.
Mensagem emitida:
feature type mismatch between Aggregate and Release (node <node-id>, attachment <instance-name>, existing type <type-in-aggregate> conflicts with <type-in-release>) (divergência de tipo de funcionalidade entre Aggregate e Release (o nó e o anexo indicados, o tipo existente no Aggregate entra em conflito com o tipo na Release))
Como corrigir: retirar o type: da Release (herdá-lo-á do Aggregate), ou alterar um dos lados para que ambos declarem o mesmo tipo. A Release pode omitir type: ou repetir o tipo do Aggregate, mas não pode substituí-lo por outro diferente.
Cyclic extends on Components or Features (Extends cíclico em Components ou Features)
A cadeia extends: de um Component ou a cadeia extends: de uma Feature volta sobre si própria.
Mensagem emitida, com Feature no lugar de Component quando a cadeia que forma o ciclo é a de uma 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 (cadeia extends cíclica (Component indicado, regra extends). A entidade estende a referência, que já está na cadeia; remova o extends da entidade ou aponte-o para uma entidade fora da cadeia)
Como corrigir: abrir a entidade que a aresta nomeia — que, ao longo de uma cadeia de três ou mais, não é a entidade nomeada no início da mensagem — e remover o seu extends: ou apontá-lo para outro sítio.
A component the composition holds is placed in no boundary (Um componente que a composição contém não está posicionado em nenhuma fronteira)
Uma Release posiciona um componente numa fronteira de duas formas, e qualquer uma delas conta. Nomeia o componente sob os components de uma fronteira, endereçado pelo id que o componente tem assim que a composição inteira é achatada. Ou encaminha o módulo que fornece o componente para uma fronteira sob aggregates, o que posiciona de uma só vez cada componente que esse módulo contém.
Um componente que não alcança nenhuma das duas é renderizado fora de todas as fronteiras que a Release declarou. O seu diretório de saída, a sua sync wave, as suas anotações e o seu infra por componente não vêm então de lado nenhum — e a compilação, de outro modo, teria êxito, emitiria os artefactos e nada diria sobre a configuração do operador nunca lhe ter sido aplicada. Dois componentes separados por essa linha são também renderizados em saídas diferentes e perdem a ordenação que têm quando posicionados em conjunto.
Duas estruturas deliberadamente não se enquadram nela. Uma Release que declara components de nível superior em vez de fronteiras com nome posiciona tudo o que nomeia: normalizar uma Release assim dá-lhe uma fronteira própria que contém exatamente esses componentes. E um componente cujo módulo inteiro a Release não posicionou em lado nenhum é, em vez disso, comunicado uma única vez em relação ao módulo, na entrada abaixo — um defeito, uma solução, uma chave a editar — em vez de uma vez por componente cuja própria declaração está correta.
Mensagem emitida. O valor no fim é o id que o componente tem assim que a composição é achatada, que, para um componente fornecido por um módulo, é o nome desse módulo, um ponto e o nome próprio do 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 não posicionado em nenhuma fronteira: nomeá-lo entre os componentes de uma fronteira, ou posicionar o submódulo que o fornece entre os agregados (com a Release, a chave escrita e o id do componente indicados))
Como corrigir: nomear o componente sob os components de uma fronteira, usando exatamente o id que a mensagem cita — para um componente fornecido por um módulo, esse é o id com prefixo, e não o nome escrito dentro do próprio ficheiro do módulo. Ou, onde o módulo inteiro pertence a uma única fronteira, encaminhá-lo para lá sob aggregates e deixar que cada componente que contém seja posicionado de uma só vez.
A sub-module’s components are placed in no boundary (Os componentes de um submódulo não estão posicionados em nenhuma fronteira)
A forma à escala do módulo da regra acima: um módulo que a composição incluiu forneceu componentes, e nenhuma fronteira contém nenhum deles. É comunicada uma única vez para o módulo em vez de uma vez por componente, porque um módulo não posicionado em lado nenhum é um único defeito de autoria com uma única solução numa única chave — e comunicá-la por componente nomearia componentes cujas próprias declarações estão perfeitamente corretas.
A regra lê o posicionamento, e não a grafia, pelo que um módulo cujos componentes são nomeados cada um individualmente sob os components de uma fronteira está posicionado e passa: recusá-lo por falta de uma entrada de encaminhamento rejeitaria uma forma de autoria que a linguagem admite. Um módulo posicionado apenas em parte também passa — quais dos seus componentes têm entradas próprias é uma questão da regra dos componentes, e os que deixou de fora são aí comunicados, cada um na sua própria chave.
Um módulo que não forneceu nenhum componente não se enquadra nela: não há nada a posicionar. Nem um que um interruptor active: em false removeu, que nunca chegou a ser composto.
Mensagem emitida, posicionada na entrada aggregates que declarou o módulo, sob o nome local que o documento importador escreveu:
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 não posicionado em nenhuma fronteira: encaminhá-lo para uma fronteira entre os agregados, ou nomear aí os seus componentes entre os componentes (com a Release, a chave escrita e o caminho do módulo indicados))
Como corrigir: adicionar uma entrada aggregates para o módulo sob a fronteira a que pertence, o que posiciona cada componente que fornece. Ou, onde os seus componentes pertencem a fronteiras diferentes, nomear cada um deles sob a fronteira a que pertence, usando os id com prefixo que têm depois de achatados.
A boundary names a component the composition does not hold (Uma fronteira nomeia um componente que a composição não contém)
A contrapartida por excesso de nomes das duas regras acima, e uma questão separada em vez de um ramo de qualquer uma delas: aquelas perguntam, de um componente, se algo o posicionou; esta pergunta, de uma entrada que a Release escreveu, se algo lhe corresponde. Nenhuma implica a outra. Uma Release pode nomear um componente que não existe enquanto cada componente que existe está devidamente posicionado, e pode deixar um componente real por posicionar enquanto cada entrada que escreveu se resolve.
A entrada que não nomeia nada não configura nada: o seu directory, o seu subDirectory, o seu syncWave, as suas anotações e o seu infra por componente são escritos para um componente que não existe, pelo que nada é renderizado sob eles e a compilação, de outro modo, teria êxito com a configuração do operador silenciosamente inerte.
Uma fronteira nomeia um componente de duas formas, e ambas são verificadas. Sob components, uma entrada endereça o componente pelo id que tem assim que a composição é achatada — pelo que um componente fornecido por um módulo é escrito com o prefixo desse módulo antes do seu próprio nome. Dentro de uma entrada de encaminhamento aggregates, uma entrada endereça o componente pelo nome local que tem dentro desse módulo, que se resolve no mesmo id. A mensagem cita o id que a entrada endereçou, que no eixo encaminhado não é o nome que o ficheiro escreve: o ficheiro contém a metade local e o módulo fornece o resto.
Um subsistema não contribui com nada para o id de um componente, pelo que um componente declarado dentro de um subsistema é endereçado pelo seu nome simples. Uma entrada escrita como se o subsistema fizesse parte do id não endereça nada e enquadra-se nesta regra.
Um componente desligado por um interruptor active: em false não se enquadra nela. Desligar um componente é um ato de autoria, e não se espera que a Release que o configura seja reescrita na mesma edição — recusar a entrada tornaria o interruptor inutilizável enquanto qualquer Release nomeasse o componente.
Mensagem emitida:
boundary names a component the composition does not hold: correct the name, or remove the entry (Release <name>, at <authored key>, "<addressed id>") (a fronteira nomeia um componente que a composição não contém: corrigir o nome, ou remover a entrada (com a Release, a chave escrita e o id endereçado indicados))
Como corrigir: comparar o id que a mensagem cita com os componentes que a composição contém realmente. Um prefixo de módulo em falta e um nome de subsistema escrito no id são as duas causas comuns; retirar o subsistema, adicionar o prefixo do módulo ou corrigir a grafia. Onde a entrada sobrou de um componente que entretanto foi removido ou mudou de nome, eliminá-la.
A uses edge targets a component an active: toggle removed (Uma aresta tem como destino um componente que um interruptor removeu)
O irmão da interrupção por destino pendente mais acima, comunicado separadamente para que o autor saiba porque o destino está em falta. O destino não está em falta por nunca ter sido declarado — está declarado, e foi deliberadamente removido desta compilação porque o seu interruptor active: se resolveu em false, levando consigo as suas arestas. Um componente que sobreviveu continua a depender dele, e deixar a aresta desaparecer deixaria silenciosamente vazios os valores injetados desse consumidor no momento da implementação.
Mensagem emitida. Primeiro vem a recusa, depois o destino que o interruptor removeu e o socket em que a ligação foi cablada — depois o que fazer a esse respeito:
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. (o destino da aresta uses foi removido porque o seu interruptor active se resolveu em false: o destino indicado, cablado no socket indicado. Manter em true o interruptor do destino, ou remover a dependência dele.)
A constatação é posicionada na entrada escrita a que diz respeito, nos mesmos caminhos que a interrupção por destino pendente mais acima nomeia, e cada ligação infratora é comunicada, e não apenas a primeira.
Como corrigir: decidir qual dos dois pertence a este ambiente. Voltar a ligar o destino — onde o seu interruptor lê um parâmetro, isso significa fornecer o parâmetro para esta Release. Ou condicionar o consumidor ao mesmo interruptor, para que os dois saiam juntos e nenhuma aresta fique a apontar para o nada. Ou, onde o consumidor realmente já não precisa dele, remover a aresta do bloco uses: do consumidor.
A uses target names a module’s component the module does not export (Um destino de aresta nomeia um componente de um módulo que o módulo não exporta)
Um módulo publica a sua interface sob exportedComponents:, e um documento que importa o módulo alcança os componentes do módulo apenas através desses nomes: o nome do módulo, um ponto e um dos seus alias. Um destino de uses: que alcança um componente dentro de um módulo de qualquer outra forma — pelo nome do componente dentro do módulo, ou por um caminho que atravessa o módulo até um módulo aninhado nele — interrompe a compilação, porque a ligação ficaria associada a algo que o autor do módulo não publicou e que é livre de mudar de nome ou remover. O próprio bloco uses: de um componente, o de um anexo e uma ligação cablada por uma Release estão sujeitos a isso da mesma forma. Os módulos em que uma ligação entra são lidos a partir do sítio onde o seu consumidor se encontra, pelo que uma ligação entre dois componentes de um mesmo módulo — incluindo uma Release que os cabla um ao outro — não atravessa nenhuma interface e não é recusada. Um destino que não corresponde a nenhum componente é, em vez disso, comunicado pela interrupção por destino pendente, pelo que um nome mal escrito é comunicado uma única vez.
Mensagem emitida. Primeiro vem a recusa, depois o destino tal como foi escrito, o módulo em que entra e os alias que esse módulo exporta, e o socket — depois o que fazer a esse respeito:
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. (o destino da aresta uses nomeia um componente que o seu módulo não exporta: o destino, o módulo, os alias que exporta e o socket em que está cablado, indicados. Nomear o componente através de um dos alias exportados do módulo, ou listá-lo entre os componentes exportados do módulo.)
Um módulo que não exporta nada é designado como exportando "nothing". A constatação é posicionada na entrada escrita no documento que traçou a ligação.
Como corrigir: nomear o componente através de um alias que o módulo exporte — finance-db-subsystem.primary_db em vez de finance-db-subsystem.internal-pg-primary — ou, onde o módulo é da sua autoria e pretende publicar o componente, listá-lo sob os exportedComponents do módulo, com o seu próprio nome se for esse o nome que os importadores devem usar.
An active: toggle does not resolve to true or false (Um interruptor não se resolve em true nem em false)
Um interruptor active: chega ao construtor do grafo já resolvido num literal — um booleano escrito diretamente, ou uma referência a parâmetro na qual os valores da Release foram substituídos antes de o documento ser lido. É então lido de forma estrita: um literal que não é um booleano interrompe a compilação em vez de assumir um valor predefinido qualquer. A regra é a mesma para o interruptor de um componente e para o de um módulo.
Um literal vazio é o caso que vale a pena nomear, porque é o que um parâmetro não satisfeito produz. Um interruptor que lê {{ .parameters.<key> }} resolve-se em nada enquanto esse parâmetro não tiver valor, e ler esse nada como «presente» implementaria precisamente a entidade que o autor condicionou ao parâmetro. Só um interruptor que ninguém escreveu vale, por predefinição, como presente, e isso é lido a partir da ausência do interruptor e não do seu valor — e é por isso que escrever active: sem nada a seguir não é o mesmo que omitir a chave.
Mensagem emitida:
active toggle did not resolve to a boolean (node "<node>", active resolved to "<value>") (o interruptor active não se resolveu num booleano (o nó indicado, com active resolvido no valor indicado))
e, onde não se resolveu em absolutamente nada, com a recomendação que nomeia a 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 (o interruptor active não se resolveu num booleano (o nó indicado, com active resolvido numa cadeia vazia). um interruptor que lê um parâmetro resolve-se em nada até esse parâmetro ser satisfeito)
Como corrigir: escrever true ou false. Onde o interruptor lê um parâmetro, fornecer esse parâmetro na Release, ou dar-lhe um default: onde é declarado no Aggregate, para que cada ambiente tenha uma resposta. Para tornar uma entidade presente incondicionalmente, remover a chave active: em vez de a deixar vazia.
A module a composition imports cannot be loaded, or imports itself (Um módulo que uma composição importa não pode ser carregado, ou importa-se a si próprio)
Um Aggregate compõe outros Aggregates nomeando-os sob aggregates:, e cada um é carregado e percorrido por sua vez para que os seus componentes entrem no grafo. Duas coisas interrompem aqui esse percurso.
O módulo não pode de todo ser carregado — a referência não se resolve em nada que o catálogo possa devolver, ou o documento por trás dela não pode ser lido. O motivo que o carregador indicou é apresentado sob a interrupção em vez de incorporado nela, pelo que o que falhou é comunicado nas próprias palavras do carregador.
Ou o módulo nomeia um tipo que já está na cadeia a ser percorrida. Expandi-lo reproduziria a cadeia que o contém, sem fim. É comunicado no ponto em que a referência fecha o ciclo, nomeando tanto o tipo como o lugar que ocupa na composição.
Mensagem emitida, para uma referência circular:
sub-aggregate load failed (circular sub-aggregate reference "<module-type>", at "<path in the composition>") (falha ao carregar o subagregado (referência circular de subagregado, com o tipo de módulo e o caminho na composição indicados))
e para uma falha de carregamento, em que a interrupção se lê como a frase sozinha, posicionada no caminho do módulo, com o próprio motivo do carregador por baixo:
sub-aggregate load failed (falha ao carregar o subagregado)
Como corrigir: para uma falha de carregamento, ler o motivo sob a interrupção — um nome ou uma versão a que o catálogo não sabe responder é o caso comum, e a correção faz-se na entrada aggregates: que o nomeia. Para uma referência circular, quebrar o ciclo: o caminho na mensagem é onde a cadeia se fecha, e um dos módulos ao longo dela tem de deixar de importar aquele que o importa. Onde dois módulos precisam realmente dos componentes um do outro, a parte partilhada pertence a um terceiro módulo que ambos importem.
Two instances flatten to one identifier (Duas instâncias são achatadas num único identificador)
Compor um Aggregate achata cada componente num único conjunto, e um componente fornecido por um módulo tem o nome desse módulo, um ponto e o seu próprio nome. O conjunto recusa-se a conter duas entradas sob um mesmo identificador: a segunda substituiria a primeira, e um dos dois componentes desapareceria da saída sem que nada fosse dito a esse respeito.
Esta interrupção é a que é levantada quando os componentes de um módulo são fundidos, e a superfície de autoria não oferece os nomes que a produziriam. Cada componente que um módulo fornece tem o nome desse módulo antes do seu; um nome de instância escreve-se com letras, dígitos, - e _, pelo que não pode conter o ponto com que os dois são unidos, e dois identificadores construídos a partir de nomes de módulo diferentes não podem coincidir. Dois módulos importados sob um mesmo nome são uma única chave duplicada, e o documento é recusado ao ser carregado. Esta interrupção serve, portanto, de rede de segurança para uma composição montada por algo que não o caminho de autoria comum, e deparar com uma justifica comunicá-la em vez de a contornar.
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>") (colisão de ID de nós achatados: mudar o nome de uma das instâncias em colisão para que os seus ID achatados sejam diferentes (o identificador e o caminho na composição indicados, em colisão com a entrada existente proveniente do outro contribuidor indicado))
Como corrigir: mudar o nome de uma das duas instâncias que a mensagem nomeia, no documento que a declara e em cada entrada de Release que a endereça.
Two subsystems declare a component under one name (Dois subsistemas declaram um componente com um mesmo nome)
Os subsistemas agrupam os componentes de um Aggregate para quem lê e para o que se propaga em cascata para eles; não qualificam o nome a que um componente responde. Um componente declarado sob subsystems.frontend é endereçado como api, e não como frontend.api, e um fornecido por um módulo tem o nome desse módulo em vez do nome do subsistema. Assim, dois subsistemas de um mesmo Aggregate podem declarar cada um um componente chamado api, e os dois passam então a responder ao mesmo identificador.
O documento está bem formado — os dois são chaves separadas em blocos separados, e é exatamente por isso que nada o recusa antes — mas apenas um componente pode ter um identificador. A compilação para em vez de manter o que foi lido em último lugar e renderizar como se tivesse sido declarado um único componente.
O mesmo nome duas vezes dentro de um mesmo subsistema é um defeito diferente: são duas entradas sob uma mesma chave, e o documento é recusado ao ser lido.
Mensagem emitida:
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 em subsistemas diferentes assumem a mesma identidade: mudar o nome de um deles, já que um subsistema não contribui com nada para a identidade de um componente (com o Aggregate, o caminho e o identificador indicados, declarado sob os subsistemas indicados))
Como corrigir: mudar o nome de um dos dois componentes, no documento que o declara e em cada entrada de Release que o endereça. Onde os dois são realmente o mesmo componente pretendido em dois lugares, declará-lo uma única vez e fazer o outro subsistema depender dele. Mudar o nome do subsistema não ajuda: o subsistema não faz parte do nome.
A re-published component alias points back at itself (Um alias de componente republicado aponta para si próprio)
Um módulo publica parte de si próprio exportando componentes sob alias, e um Aggregate que o importa pode republicar um desses alias sob um nome próprio. Resolver um alias assim segue a cadeia de republicações até ao componente que ele nomeia em última instância, para que uma aresta que aponta para o nome público alcance um componente real.
Uma cadeia que volta a passar por um alias antes de alcançar um componente nunca chega ao fim. O percurso para em vez de a seguir indefinidamente, e nomeia a cadeia que percorreu para que o elo que fecha o ciclo fique visível.
Nada do que se pode escrever produz uma cadeia assim. A árvore de importações é acíclica, e cada elo nomeia algo aninhado mais profundamente do que o elo anterior, pelo que uma cadeia montada a partir de importações desce e termina. Esta interrupção serve, portanto, de rede de segurança para uma tabela de alias montada por algo que não o caminho de autoria comum, e não para uma estrutura que um Aggregate possa declarar.
Mensagem emitida:
re-exported component alias forms a cycle (alias chain <first> -> <second> -> <first>) (o alias de componente reexportado forma um ciclo (com a cadeia de alias indicada))
Como corrigir: nada nos ficheiros escritos o produz, e não há nenhuma alteração de autoria que o elimine. Comunicá-lo com o comando executado e a cadeia de alias que a mensagem nomeia, que é o detalhe que indica onde o ciclo se fechou.
An Aggregate reached graph building without being normalised (Um Aggregate chegou à construção do grafo sem ter sido normalizado)
Um Aggregate escrito com componentes no seu nível superior e um escrito com subsistemas com nome assumem a mesma forma ao serem lidos: os componentes de nível superior são incorporados num subsistema que o compilador fornece, e o nível superior é esvaziado. É essa incorporação que permite que tudo o que vem a seguir faça uma única pergunta a uma única forma.
Um Aggregate que chega à construção do grafo com ambos preenchidos não foi produzido por essa leitura. As duas formas são mutuamente exclusivas onde são escritas — um documento que declare ambas é recusado ao ser carregado — e a incorporação é o que as torna uma única forma depois, pelo que nada que um autor possa escrever chega até aqui. Esta interrupção serve de rede de segurança para um Aggregate montado por algo que não o caminho de carregamento comum, e deparar com uma justifica comunicá-la em vez de a contornar.
A sua mensagem começa assim:
aggregate reached topology un-normalized (non-empty root components alongside a synthesized default subsystem) (o agregado chegou à topologia sem estar normalizado (componentes raiz não vazios ao lado de um subsistema predefinido sintetizado))
e continua com o caminho de construção que o compilador espera, que é uma nota para quem está a depurar a compilação e não uma instrução de autoria.
Como corrigir: nada nos ficheiros escritos o produz, e não há nenhuma alteração de autoria que o elimine. Comunicá-lo com o comando executado.
A label-transform plugin’s patch reaches outside node labels (O patch de um plugin label-transform vai além dos rótulos dos nós)
Um plugin de governação anexado num papel label-transform recebe uma projeção do grafo — uma entrada por nó, com os rótulos desse nó e os valores que a sua instância declara, sendo retido qualquer valor que o seu Component declare sensível — e devolve patches sobre os rótulos dos nós. O host aplica-os apenas aos rótulos e depois verifica se o que voltou continua a ser essa vista dos rótulos: os mesmos nós, cada um apenas com rótulos, cada valor de rótulo uma string.
Qualquer outra coisa é recusada e a compilação para. Adicionar ou remover um nó, ou alterar um campo de um nó que não sejam os seus rótulos, é precisamente o aparecimento silencioso de infraestrutura que ninguém declarou — pelo que, em vez de absorver uma alteração que o papel não abrange, a compilação diz que regra de confinamento o patch violou. Os rótulos são toda a superfície do papel, e um operador que anexou o plugin declarou isso e nada mais.
Mensagens emitidas. O patch foi recusado antes de ser aplicado:
mutator patch rejected: patch <n> does not decode as a JSON Patch document: <what the reader could not do> (patch do mutador recusado: o patch indicado não é descodificado como um documento JSON Patch: o que o leitor não conseguiu fazer) mutator patch rejected: patch <n> does not apply to the node-label surface: <what the patch engine refused> (patch do mutador recusado: o patch indicado não se aplica à superfície de rótulos dos nós: o que o motor de patches recusou)
ou o resultado de o aplicar não era a vista que o host tinha entregado:
mutator patch rejected: mutated node set changed size (a mutator may not add or remove nodes) (patch do mutador recusado: o conjunto de nós mutado mudou de tamanho (um mutador não pode adicionar nem remover nós)) mutator patch rejected: mutated node set introduced node "<node>" (a mutator may not add nodes) (patch do mutador recusado: o conjunto de nós mutado introduziu o nó indicado (um mutador não pode adicionar nós)) mutator patch rejected: node "<node>" gained a field outside "labels" (a mutator may only touch labels) (patch do mutador recusado: o nó indicado ganhou um campo fora dos rótulos (um mutador só pode mexer nos rótulos)) mutator patch rejected: node "<node>" lost its "labels" field (patch do mutador recusado: o nó indicado perdeu o seu campo de rótulos) mutator patch rejected: node "<node>" carries a non-string label value after patching: <what the reader found> (patch do mutador recusado: o nó indicado tem um valor de rótulo que não é uma string após a aplicação do patch: o que o leitor encontrou)
Como corrigir: o defeito é do plugin e não dos seus documentos. Corrigi-lo para que cada operação que devolve se dirija a uma entrada sob os labels de algum nó e defina apenas valores string — um valor de rótulo numérico ou booleano é o caso comum, uma vez que a superfície só aceita strings. Remover o anexo de plugins.governance é a forma imediata de desbloquear uma compilação enquanto o plugin é corrigido.
Omissão intencional: não se exige que a topologia seja acíclica
A Aggrega permite ciclos na topologia: não exige que o grafo de dependências seja um grafo acíclico dirigido. Arquiteturas agente a agente, padrões de callback e pares de autenticação mútua produzem todos arestas cíclicas, e o compilador aceita-as. A ordenação no momento da implementação cabe ao renderizador (através de um syncWave por fronteira ou equivalente), e não ao grafo IR.
Ao verificar os contratos de inject
O compilador percorre cada bloco inject: — tanto self-inject (um Component que injeta em si próprio) como uses-inject (cablagem de um Component para outro) — e valida o contrato de entrega em relação ao esquema provides: do Component de destino, à partição de rótulos da Feature e ao conjunto de chaves de entrega declaradas. Uma chave from: num bloco que o próprio componente do Aggregate escreveu é verificada assim que o catálogo é resolvido, pelo que falha na linha que escreveu; uma no bloco de um componente fornecido por um módulo é verificada assim que a composição que importa o módulo é construída, e falha na linha do próprio documento do módulo; uma chave from: numa ligação fornecida por uma Feature anexada é verificada assim que todas as superfícies capazes de traçar uma ligação tiverem contribuído, que é o primeiro momento em que uma ligação assim existe para ser verificada.
Inject from key is not in the target’s provides (A chave de inject não está entre o que o destino fornece)
Uma entrada inject: faz referência a uma chave from: que a fonte de onde lê não publica: o esquema provides: do Component de destino para o próprio bloco de um componente ou para uma ligação, e a FeatureRecipe da Feature anexada para o próprio bloco inject: de uma Feature anexada.
A verificação aplica-se onde quer que a ligação tenha sido escrita. Uma ligação uses: chega à topologia construída a partir de mais do que uma superfície de autoria — o próprio bloco uses: de um Component e o bloco uses: de uma Feature anexada a ele, quer esse anexo esteja escrito no componente, num subsistema, numa fronteira da Release ou na entrada de componente de uma fronteira da Release — e a mesma chave mal escrita é recusada em cada uma delas. O diagnóstico aponta para o bloco cujo autor a escreveu: a própria entrada uses: de um anexo, no local onde o próprio anexo foi declarado, e não o bloco uses: do componente consumidor, que, para uma ligação fornecida, não contém absolutamente nada.
Aquilo em relação ao qual a referência é resolvida depende de onde ela se encontra. Um from: de self-inject ao nível do Component é resolvido em relação ao próprio provides: desse mesmo Component. Um from: numa ligação uses: é resolvido em relação ao provides: do componente para o qual essa ligação aponta — e, onde duas superfícies escrevem um mesmo socket e um mesmo alias, cada ligação é resolvida em relação ao destino que ela própria nomeia, na mesma compilação que recusa o par por partilhar um alias. Um Component que não declara nenhum provides: recusa todas as referências from: dirigidas a ele.
O próprio bloco inject: de uma Feature anexada. Aí, um from: é resolvido em relação às chaves que a FeatureRecipe da Feature publica no seu provides:, tal como avaliadas para o componente ao qual a Feature está anexada, e é verificado quando esse componente é renderizado. Uma chave que a FeatureRecipe não publica não colocaria nada no ambiente, no ficheiro ou no argumento do componente, pelo que a build é interrompida — a menos que a FeatureRecipe leia ela própria as entradas da Feature anexada, em .inject, num template que avalia em relação ao próprio contexto de renderização da Feature anexada — aquele que contém .inject: o seu mapeamento de valores, a sua carga de trabalho, os seus artefactos, as suas omissões ou o with: ou o when: de um passo do pipeline, escritos inline ou importados. Os seus locals:, provides:, source: e assertions: não contêm .inject, e o seu injectMapping: é avaliado em relação ao contexto do componente, pelo que uma leitura em qualquer um deles não conta. Uma FeatureRecipe deste tipo recebe cada entrada tal como foi escrita e entrega-a à sua maneira, pelo que as suas entradas não são recusadas, e uma chave que não publica não entrega nada através da entrega própria do componente e fica à disposição da FeatureRecipe. Se uma FeatureRecipe lê .inject decide-se a partir dos caminhos que os seus templates nomeiam: um template que passa adiante todo o seu contexto (toJson .) ou que chega às entradas através de uma função como index . "inject" não conta como leitura das entradas, e as suas entradas que nomeiam uma chave não publicada são recusadas. Uma Feature anexada numa fronteira cuja FeatureRecipe é renderizada uma vez para essa fronteira é verificada em relação a essa única avaliação; onde nenhuma fronteira que contém o componente produziu uma, não há nada em relação ao qual verificar as suas chaves e estas não são recusadas. Um from: que nomeia uma chave publicada entrega como antes. A constatação é posicionada na própria entrada da Feature anexada, no documento que a escreveu — .spec.components.<component>.features.<attachment> no Aggregate, por exemplo — e uma entrada cuja chave de entrega outra fonte de inject também já detém é comunicada também em «An attachment delivers a key another inject source already claimed (Um anexo entrega uma chave que outra fonte de inject já reivindicou)», uma vez que cada uma precisa da sua própria correção.
No próprio bloco inject: de um componente, uma entrada value: contém um literal e não é resolvida em relação a nada, pelo que um literal que por acaso se pareça com uma chave provides não é aí recusado; numa ligação, uma entrada value: é recusada, como descreve «An inject: entry on a connection carries a literal (Uma entrada de inject numa ligação traz um literal)» mais abaixo. Só from: nomeia uma chave.
A própria superfície uses: por aresta da Release traz target e infra e nenhum inject:, pelo que uma ligação cablada aí não dita nenhuma entrega e não tem nenhuma chave from: a verificar.
Mensagem emitida, para um from: lido no próprio bloco inject: de um Component. Primeiro vem a recusa, depois a chave errada, o tipo de componente em relação ao qual foi resolvida e as chaves declaradas desse tipo, ordenadas — as alternativas entre as quais escolher:
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>") (chave inject inválida: a from-key tem de nomear uma chave provides que a sua fonte publica (com o Aggregate, o caminho, a from-key, o tipo de componente e as chaves declaradas indicados))
Para um from: lido numa ligação uses:, a mesma recusa vem primeiro, e o mecanismo e a chave de entrega sob os quais a entrada foi escrita vêm antes da chave errada:
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>") (chave inject inválida: a from-key tem de nomear uma chave provides que a sua fonte publica (com o Aggregate e a ligação indicados, o mecanismo, a chave de entrega, a from-key, o tipo de componente e a chave declarada))
Para um from: lido no próprio bloco inject: de uma Feature anexada, a chave errada vem primeiro, depois o in: e o mecanismo da entrada, a FeatureRecipe em relação à qual foi resolvida e, por ordem, cada chave que essa FeatureRecipe publica:
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>") (chave inject inválida: a from-key tem de nomear uma chave provides que a sua fonte publica (com o Aggregate, o caminho, a from-key, o in, o mecanismo, a FeatureRecipe e as chaves publicadas indicados))
Quando o destino não declara nenhuma chave provides:, não há alternativas a listar, pelo que a mensagem termina após o tipo de componente — ou, no bloco de uma Feature anexada, após a FeatureRecipe.
Como corrigir: alterar a chave from: para corresponder a uma das chaves declaradas listadas na mensagem, ou estender o esquema provides: do Component de destino para declarar a chave necessária. No bloco de uma Feature anexada, alterar a chave from: para uma que a FeatureRecipe publique, ou — quando a FeatureRecipe for própria — publicar a chave no seu provides:, ou fazer com que ela própria leia a entrada em .inject, se entregar o valor à sua maneira.
Required feature not attached (Funcionalidade obrigatória não anexada)
O Component declara um mandato de presença — uma anotação features.aggrega.ai/requiredType.<label> — que nomeia um tipo de Feature que não está presente entre os anexos com que esta instância de componente acaba por ficar, contando cada âmbito: os blocos de nível de componente e de nível de subsistema do Aggregate, os blocos de nível de fronteira e de nível de componente da Release, e a expansão orientada por anotações.
Mensagem emitida:
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>) (funcionalidade obrigatória em falta: anexar ao componente uma Feature do tipo exigido (o tipo exigido indicado, exigido pelo tipo de componente indicado, sob o rótulo de requisito indicado))
Os três valores são o tipo de Feature que o mandato exige — que a frase anterior já nomeia, pelo que aparece sem legenda —, depois o tipo de componente que declara o mandato e o rótulo que o mandato tem, cada um com legenda para que um leitor consiga distinguir duas referências a entidades. Um componente que exige dois tipos diferentes comunica duas mensagens que diferem, e dois componentes que declaram o mandato a partir de tipos diferentes ficam a saber que tipo fez cada exigência. A constatação é posicionada na própria chave do componente sob components:, e um componente escrito dentro de um subsistema é posicionado primeiro sob a chave desse subsistema.
O nome sob o qual um anexo é escrito não importa aqui: o mandato pergunta se existe algum anexo do tipo nomeado. Associar um slot satisfá-lo, e o mesmo faz um anexo sob qualquer outro nome.
Como corrigir: anexar uma Feature do tipo exigido ao componente no Aggregate ou na Release, ou num âmbito mais amplo do qual o componente herda. Se o Component já não dever exigi-la, remover a anotação do mandato da sua declaração de catálogo.
Malformed attachment requirement (Requisito de anexo malformado)
A declaração de um mandato de presença não pode ser avaliada. O valor de uma anotação é uma string opaca, pelo que nada valida a sua forma antes de o compilador a ler: um valor que não é um URI de tipo de Feature, ou uma chave que nomeia a família de mandatos sem um rótulo após o prefixo, é comunicado como uma declaração defeituosa e não como um requisito não satisfeito — uma gralha nunca deve ser lida como um requisito satisfeito.
Mensagens emitidas:
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 anexo malformado (a chave indicada, declarada pelo tipo de componente indicado, que não pode ser avaliada porque o valor tem de ser um URI de tipo de Feature na forma publicador/nome em segmentos kebab em minúsculas, como no exemplo indicado). Corrigir essa anotação na entidade de catálogo do 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 anexo malformado (a chave indicada, declarada pelo tipo de componente indicado, que não pode ser avaliada porque a chave precisa de um rótulo que nomeie o requisito, como no exemplo indicado). Corrigir essa anotação na entidade de catálogo do tipo de componente.)
A mensagem começa pela chave da anotação — a declaração de que trata a interrupção — e nomeia a seguir o tipo de componente cuja declaração está defeituosa, de modo que nomeia a entidade a corrigir, mesmo que a constatação seja posicionada na instância de componente que usa esse tipo: a instância é onde a vê, e a entidade de catálogo é onde está a solução.
Esta interrupção é levantada assim que a composição é montada, o que acontece antes de qualquer verificação que leia o grafo concluído. Uma compilação com um mandato defeituoso comunica-o, portanto, isoladamente: as verificações que seriam executadas depois não são alcançadas, porque raciocinam sobre o que a declaração diz e a declaração não pode ser lida. Corrigi-lo e voltar a compilar para ver o resto.
Como corrigir: corrigir a entidade de catálogo do Component. A solução está no catálogo e não no Aggregate — e é por isso que esta interrupção é distinta de «Required feature not attached (Funcionalidade obrigatória não anexada)», onde são os seus próprios documentos que têm de ser alterados.
Required attachment slot not bound (Slot de anexo obrigatório sem associação)
Uma entidade de catálogo declara um slot de anexo com required: true no seu featuresSchema, e nada associa o nome desse slot numa instância da entidade. A verificação é executada sobre os anexos com que a instância acaba por ficar depois de todos os âmbitos serem combinados — os blocos features: de nível de componente e de nível de subsistema do Aggregate, os blocos de nível de fronteira e de nível de componente da Release, e os anexos produzidos pela expansão orientada por anotações —, pelo que uma credencial anexada uma vez num âmbito do qual a instância herda associa o slot exatamente como um preenchimento escrito na instância.
Mensagem emitida:
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 anexo obrigatório não preenchido (o slot indicado, declarado obrigatório pelo tipo de componente indicado). Anexar uma Feature com esse nome, no Aggregate ou na Release, no componente ou num âmbito acima dele.)
Os dois valores são o próprio nome do slot e o tipo de componente que o declara, pelo que uma instância que deixa dois slots sem associação comunica duas mensagens que diferem. A constatação é posicionada na chave do slot sob o bloco features: do componente no Aggregate; como essa chave é exatamente o que falta, um editor coloca-a na chave existente mais próxima — o bloco features:, onde o componente escreve um, e o próprio componente, onde não escreve. Nada escreveu o anexo em falta, pelo que nenhum autor de documento é apontado por ela: a constatação fica no componente e é classificada como defeito do programador, e a solução nomeia ambos os documentos, porque qualquer um deles pode preencher o slot — o Aggregate no componente ou num subsistema que o contenha, a Release na sua entrada para o componente ou numa fronteira que o contenha.
Um slot que um socket declara — no featuresSchema de uma entrada de usesSchema — é exigido a cada ligação cablada através do socket, e não ao componente: cada ligação preenche-o para si própria, na sua própria entrada no Aggregate ou na Release, e nenhum âmbito acima o alcança. Assim, um socket com duas ligações, uma das quais preenche o slot, comunica apenas a outra, nomeando-a:
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 anexo obrigatório não preenchido (o slot indicado, declarado obrigatório pelo socket indicado, do tipo de componente indicado, deixado por preencher pela ligação indicada). Anexar uma Feature sob esse slot nas funcionalidades desta ligação, na sua entrada no Aggregate ou na Release.)
Essa constatação é posicionada na entrada da ligação no documento que traçou a ligação — a entrada uses: do Aggregate, ou a entrada por aresta da Release para uma ligação que a Release cablou. Uma ligação que uma Feature anexada traça é cablada num socket que a Feature declara, e não num do componente, pelo que não lhe cabe preencher os slots dos sockets do componente.
Como corrigir: anexar uma Feature sob o nome do slot, no Aggregate ou na Release — no componente, ou num âmbito mais amplo que todos os consumidores do slot partilhem; para o slot de um socket, na ligação que a constatação nomeia. Um anexo sob um nome diferente não associa o slot: um slot é um ponto de associação com nome, pelo que o nome é a associação. Se o slot já não dever ser obrigatório, atualizar o featuresSchema da entidade de catálogo — o do próprio componente ou o do socket — para remover a declaração required.
Two Features declared to conflict reach one component (Duas Features declaradas em conflito alcançam um mesmo componente)
O campo interoperability.conflictsWith de uma Feature nomeia as Features ao lado das quais não pode ser anexada, e um componente acaba por ter a Feature e uma das que ela nomeia. A verificação é executada sobre os anexos com que o componente acaba por ficar depois de todos os âmbitos serem combinados — os blocos features: de nível de componente e de nível de subsistema do Aggregate, os blocos de nível de fronteira da Release (todas as fronteiras dentro das quais o componente se encontra, incluindo as aninhadas) e as suas entradas de nível de componente, e os anexos produzidos pela expansão orientada por anotações. Assim, um par provoca a interrupção quando ambas estão escritas no componente, quando uma está numa fronteira ou num subsistema que o contém, ou quando uma se encontra numa fronteira exterior e a outra numa fronteira aninhada dentro dela. Duas Features anexadas a fronteiras irmãs que não partilham nenhum componente nunca se encontram, e uma fronteira que não contém nenhum componente não alcança nada, pelo que nenhum desses casos provoca a interrupção.
Basta uma declaração: a interrupção é acionada quando a lista de uma ou outra Feature nomeia a outra. Os nomes são comparados sem qualquer versão, dos dois lados, de modo que uma entrada corresponde a todas as versões da Feature que nomeia. O compilador compara os nomes que o autor da Feature declarou com as Features que o componente tem e não lê nada mais em nenhum dos dois.
Mensagem emitida:
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. (uma Feature alcança um componente ao lado de uma Feature com a qual declara um conflito (a Feature indicada, anexada na Release na fronteira indicada, entra em conflito com a outra Feature indicada, anexada no Aggregate no componente indicado, no componente indicado). Anexar apenas uma das duas onde se encontram: remover um anexo, ou movê-lo para um âmbito que não contenha este componente.)
O primeiro valor é a Feature cuja lista nomeia a outra — a que a frase anterior nomeia — seguida de cada local onde foi anexada; depois a Feature com a qual está em conflito, e cada local onde essa foi anexada; e por último o componente onde se encontram. Cada local é expresso nas palavras do documento que se abriria para o alterar: attached in the Aggregate on component, attached in the Aggregate on subsystem, attached in the Release on boundary (o caminho de uma fronteira aninhada une os seus níveis com /), attached in the Release on the entry for component seguido de in boundary, ou attached by annotation-driven expansion of seguido da anotação, e de declared at com o local onde foi escrita. Um anexo escrito numa ligação é expresso como a entrada dessa ligação, uma vez que é essa entrada, e não o próprio bloco do componente, o local onde é editado: attached in the Aggregate on the connection seguido de through socket e of component, ou attached in the Release on the connection seguido de through socket, of the entry for component e in boundary. Uma Feature anexada em dois locais lista ambos. A constatação é posicionada na própria chave do componente sob components:, e um par que se encontra em vários componentes é comunicado uma vez para cada um deles, pela ordem em que o Aggregate declara os componentes.
Como corrigir: anexar apenas uma das duas onde se encontram — remover um dos anexos, ou mover um para um âmbito que não contenha este componente, como uma fronteira irmã. Onde o anexo veio da expansão orientada por anotações, o que deve ser alterado é a anotação, e não o bloco sobre o qual se expandiu. Se as duas Features puderem de facto ser combinadas, o que está errado é a declaração: remover a outra Feature da lista conflictsWith na entidade de catálogo da Feature que a declara.
Attachment does not conform to its declared slot shape (O anexo não está em conformidade com a forma declarada do seu slot)
Um anexo associa um slot declarado, mas não corresponde à forma que esse slot declara. O caso comum é a entrega: a lista de permissões inject de um slot nomeia os mecanismos através dos quais um preenchimento pode entregar o seu material, e uma lista de permissões vazia é blackbox — a Recipe entrega o material internamente e um preenchimento não pode ditar nenhuma entrega. Um bloco inject: {} vazio não dita nenhuma entrega, pelo que está na forma correta para qualquer slot, incluindo um com lista de permissões vazia, e recebe o mesmo veredicto onde quer que o anexo seja escrito: num componente que o Aggregate declara, num componente fornecido por um módulo importado ou num âmbito mais amplo. Um anexo sob um nome que nenhum slot declara é um anexo livre e não tem nenhuma restrição de slot.
Mensagem emitida, quando o anexo dita uma entrega que o seu slot não aceita — o slot, depois o mecanismo, depois cada mecanismo que a lista de permissões inject do slot aceita, pela ordem em que o slot os declara (para uma lista de permissões vazia não se segue nenhum):
attachment does not conform to its declared slot shape (Aggregate <name>, at .spec.components.<component>.features.<attachment>, "<slot>", "<mechanism>", "<permitted-mechanism>") (o anexo não está em conformidade com a forma declarada do seu slot (com o Aggregate, o caminho, o slot, o mecanismo e o mecanismo permitido indicados))
Um componente fornecido por um módulo importado é verificado assim que a composição que o importa é construída, e é comunicado numa segunda forma. Esta nomeia o Aggregate do módulo e a chave, dentro do documento do módulo, que o slot não declara — um mecanismo sob o bloco inject: do anexo, ou o próprio bloco inject:, quando indica algum mecanismo, num slot cuja lista de permissões está vazia:
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>) (o anexo não está em conformidade com a forma declarada do seu slot (com o Aggregate e o caminho indicados, o anexo não está em conformidade com a forma de slot declarada: esta chave não faz parte da declaração do slot — a solução indicada))
em que <remedy> depende da chave:
remove it, para um bloco inject: que indica um mecanismo num slot cuja lista de permissões está vazia;
remove it, or add it to the slot's inject allowlist in the entity's featuresSchema, para um mecanismo que a lista de permissões de um slot pode nomear — env, file ou arg;
remove it: a slot's inject allowlist in the entity's featuresSchema accepts only env, file and arg, para qualquer outro mecanismo, que nenhum slot pode declarar.
Um anexo declarado num âmbito mais amplo — em todo o subsistema, em cascata sobre cada componente abaixo dele — está sujeito à mesma forma, e é verificado em relação ao slot em cada componente que alcança. O mesmo anexo pode, portanto, estar em conformidade para um componente e fora de conformidade para outro, pelo que esta forma nomeia o componente e o slot em relação ao qual falhou, e localiza o anexo no âmbito onde foi declarado, e não numa chave dentro do seu bloco 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) (o anexo não está em conformidade com a forma declarada do seu slot (com o Aggregate e o caminho indicados, este anexo está declarado num âmbito que alcança o componente indicado, cujo slot de anexo indicado não aceita a entrega que contém: mover o anexo para baixo, para os componentes que o podem receber))
Um anexo que uma ligação tem nunca chega a esta interrupção. A sua forma é fechada onde é escrita: na entrada de ligação do Aggregate aceita type, description e values, e na da Release type, description e infra, pelo que não pode ditar nenhuma entrega — um inject: escrito aí é recusado quando o documento é carregado, com o nome da chave — e a entrada do Workload que o entrega está, em vez disso, sujeita à lista de permissões inject do slot do socket. Também nenhum âmbito alcança o slot de um socket, pelo que a forma de âmbito inteiro descrita acima não tem equivalente numa ligação.
Como corrigir: as formas pedem duas alterações diferentes, e o caminho do campo indica qual delas se tem. Onde nomeia um anexo num componente, ou uma chave dentro dele, o defeito está na entrega: removê-la, ou mover as suas entradas para sob um mecanismo que a lista de permissões inject do slot nomeia. Onde o material deve realmente chegar ao workload através de um mecanismo que o slot não lista, a lista de permissões no featuresSchema da entidade de catálogo pode ser alargada — mas apenas com env, file ou arg, os mecanismos que um slot pode declarar; um Component que aí nomeie qualquer outro mecanismo falha a validação quando é carregado, pelo que, para qualquer outro mecanismo, removê-lo é a única correção. Onde nomeia um anexo num âmbito, o anexo está bem formado e o defeito está no seu posicionamento: movê-lo para baixo, para os componentes cujo slot aceita a entrega, deixando fora do seu alcance os componentes que reservam a entrega à sua Recipe.
Duplicate delivery key across inject sources (Chave de entrega duplicada entre as fontes de inject)
A mesma chave de entrega (por exemplo, o mesmo nome de variável de ambiente) é reivindicada duas vezes entre as fontes de inject escritas pelo programador para um componente — ao nível do Component e sob uma entrada uses[], por duas entradas uses[] no mesmo componente, ou sob dois mecanismos de entrega do próprio bloco inject: do Component. A entrega não pode vir de dois locais ao mesmo tempo, pelo que uma chave reivindicada duas vezes é uma contradição, e não uma questão de saber qual delas prevalece.
A compilação lê isto em quatro locais, porque estes veem conjuntos diferentes de fontes escritas e de ligações de dependência e lhes fazem perguntas diferentes, e cada um comunica na sua própria forma.
O primeiro lê as ligações que escreveu no Aggregate, e comunica enquanto os seus ficheiros são resolvidos. Nomeia o mecanismo de entrega, a chave e, depois, o socket e o alias da primeira ligação, pela ordem de escrita, que também a reivindica:
duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<socket>", "<alias>") (chave de entrega duplicada entre as fontes de inject (com o Aggregate, o caminho, o mecanismo, a chave, o socket e o alias indicados))
O segundo lê esse mesmo bloco escrito e faz-lhe uma pergunta diferente: se o componente reivindica uma chave sob dois dos seus próprios mecanismos de entrega, sem nenhuma ligação envolvida. Comunica uma vez por cada mecanismo que reivindica a chave, posicionado na própria entrada desse mecanismo, e nomeia o mecanismo de que trata a constatação, a chave e, depois, cada outro mecanismo que a reivindica, pela ordem de escrita:
duplicate delivery key across inject sources (Aggregate <name>, at .spec.components.<component>.inject.<mechanism>.<key>, "<mechanism>", "<key>", "<other-mechanism>") (chave de entrega duplicada entre as fontes de inject (com o Aggregate, o caminho, o mecanismo, a chave e o outro mecanismo indicados))
Nenhum dos dois mecanismos é o infrator, e cabe-lhe agir sobre ambas as constatações: mudar o nome da chave sob um deles, ou descartar uma das duas entregas. Que mecanismos um componente pode usar é uma questão separada, à qual responde a sua lista de permissões spec.inject — ver «Self-inject mechanism not in the component’s allowlist (Mecanismo de self-inject fora da lista de permissões do componente)» mais abaixo.
Um componente fornecido por um módulo também encontra estas duas primeiras formas, lidas do próprio documento do módulo assim que a composição que o importa é construída; estas nomeiam então o Aggregate do módulo e a chave dentro do seu documento.
O terceiro lê as ligações que a topologia concluída tem, incluindo as que um anexo de Feature forneceu em seu nome. É executado antes de qualquer renderização, e nomeia a chave de entrega que escreveu juntamente com o socket de dependência que também a entrega:
duplicate delivery key across self-inject and uses-inject ("<key>", socket "<socket>") (chave de entrega duplicada entre self-inject e uses-inject (a chave indicada, o socket indicado))
Uma chave escrita entregue através de dois sockets de dependência é comunicada uma vez por socket, pelo que uma única compilação informa sobre todos eles, e não apenas sobre o que foi alcançado primeiro.
O quarto lê a mesma topologia concluída e faz-lhe uma pergunta diferente: se duas das próprias ligações de dependência de um componente entregam uma mesma chave entre si, sem que o próprio componente reivindique nada. Comunica uma vez em cada ligação, posicionado na própria entrada de entrega dessa ligação, e nomeia o caminho da entrada seguido de cada socket que entrega a chave:
duplicate delivery key across inject sources ("inject.<mechanism>.<key>", "<socket>", "<socket>") (chave de entrega duplicada entre as fontes de inject (com o caminho da entrada e os sockets indicados))
Um socket nomeado duas vezes é o que indica que as duas ligações se encontram num mesmo socket sob aliases diferentes — aí a posição é a única coisa que as separa, pelo que se deve ler o caminho do campo de cada uma das duas constatações, e não os nomes dos sockets.
Nenhuma das duas ligações é a infratora, e cabe-lhe agir sobre ambas: mudar o nome de uma das chaves, ou descartar uma das duas entregas.
Onde a chave é um caminho, o caminho do campo nomeia, em vez disso, o bloco do mecanismo. O que uma chave de entrega exprime é assunto do próprio mecanismo, e um mecanismo file entrega num caminho de montagem — pelo que uma chave assim contém pontos, enquanto um caminho do campo separa os seus próprios passos com eles. Um caminho do campo para no último passo que consegue nomear sem ambiguidade, em vez de escrever um que seria lido como um percurso por chaves que o documento não contém, pelo que, para uma chave como /etc/app/config.yaml, se lê .spec.components.<component>.inject.<mechanism> e para aí. A mensagem nomeia a chave em qualquer caso, e é isso que mantém a constatação igualmente acionável — mas o ponto da mensagem onde a ler difere entre as quatro formas acima, pelo que se deve ler o caminho do campo para o bloco e depois tirar a chave daquela das quatro que se tem: onde o detalhe começa pelo mecanismo de entrega, a chave é o valor entre aspas imediatamente a seguir; onde o detalhe começa pela chave isolada, é o primeiro valor entre aspas; e onde o detalhe começa pelo próprio caminho da entrada de entrega, a chave é o último passo desse caminho.
Como corrigir: mudar o nome de uma das chaves em conflito, ou descartar a declaração duplicada. Note-se que o injectMapping de uma FeatureRecipe que reescreve uma chave entregue pelo próprio bloco inject: do componente ou por um dos blocos inject: das suas ligações é uma interceção intencional e não é assinalado aqui nem em nenhum outro lugar.
Uma chave reivindicada por uma Feature anexada ao componente encontra o mesmo espaço partilhado a partir da terceira das suas três superfícies de autoria, e é comunicada sob «An attachment delivers a key another inject source already claimed (Um anexo entrega uma chave que outra fonte de inject já reivindicou)» mais abaixo; uma chave que duas Features anexadas entregam, em que a posterior das duas a entrega através do injectMapping da sua FeatureRecipe, é comunicada sob «Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Duas Features anexadas entregam uma mesma chave, a posterior através do injectMapping da sua FeatureRecipe)».
Self-inject on a component without an allowlist (Self-inject num componente sem lista de permissões)
O programador escreveu um bloco inject: ao nível do componente, mas a entidade de catálogo do Component não declara spec.inject. Components sem uma lista de permissões spec.inject são tipos Black-Box — não recebem nenhuma injeção escrita pelo programador.
Mensagem emitida:
self-inject on component without spec.inject allowlist (Aggregate <name>, at .spec.components.<component>.inject, "inject", "<component-type>") (self-inject num componente sem lista de permissões spec.inject (com o Aggregate, o caminho, a chave inject e o tipo de componente indicados))
A constatação é posicionada no próprio bloco inject:, que é o elemento a remover.
Como corrigir: remover o bloco inject: desta instância de Component, ou mudar para um tipo de Component White-Box cuja declaração de catálogo inclua spec.inject.
Self-inject mechanism not in the component’s allowlist (Mecanismo de self-inject fora da lista de permissões do componente)
O programador escreveu um bloco inject: ao nível do componente usando um mecanismo (por exemplo, env ou uma forma específica de montagem de ficheiros) que não consta da lista de permissões spec.inject do Component.
Mensagem emitida:
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 num componente sem lista de permissões spec.inject (com o Aggregate, o caminho, o tipo de componente, o mecanismo e os mecanismos permitidos indicados))
Os mecanismos que o tipo permite vêm a seguir ao que foi ditado, pelo que a mensagem contém tanto o que foi escrito como o que o tipo permite. Um tipo que não declara nenhuma lista de permissões comunica o mecanismo ditado sem nada a seguir.
Tanto esta regra como a anterior aplicam-se a um componente fornecido por um módulo, assim que a composição que importa o módulo é construída; a constatação nomeia então o Aggregate do módulo e a chave dentro do seu documento.
Como corrigir: mudar para um mecanismo da lista de permissões, ou, se o Component deve suportar o mecanismo necessário, estender a sua lista de permissões spec.inject no catálogo.
uses edge dictates delivery on a socket that allowlists none (Uma aresta dita a entrega num socket que não permite nenhum mecanismo)
Um bloco inject: numa aresta uses: é cablado num socket cuja entrada de usesSchema não declara nenhuma lista de permissões inject:, ou declara uma vazia. Um socket assim é uma ligação Black-Box: a entidade que o declarou trata internamente os valores da dependência, pelo que o consumidor recebe aquilo que a Recipe do produtor emitir e não escolhe a forma de entrega. Uma chave inject: ausente e inject: [] são a mesma declaração.
O socket é lido na entidade que o declarou, seja ela qual for: uma aresta escrita num anexo de Feature é resolvida em relação ao usesSchema da Feature anexada, e todas as outras arestas em relação ao do Component consumidor.
Mensagem emitida. Primeiro vem a recusa, depois os mecanismos que a aresta ditou, o socket e a entidade cuja declaração foi lida — e depois o que fazer a esse respeito:
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. (o inject da aresta uses dita um mecanismo de entrega que o socket não permite (o mecanismo indicado, no socket indicado, declarado no tipo de componente indicado). O socket não declara nenhuma lista de permissões de entrega, pelo que não permite ditar nada — a entidade que o declarou entrega ela própria os valores da dependência. Remover o bloco inject desta ligação e ler os valores a partir dos provides da ligação na Recipe consumidora, ou declarar os mecanismos que o socket permite na sua entrada de usesSchema.)
A constatação é posicionada na entrada escrita a que diz respeito, no documento em que essa entrada foi escrita: .spec.components.<consumer>.uses.<socket>.<alias> para uma aresta que o próprio bloco uses: de um componente traçou, e .spec.components.<consumer>.features.<attachment>.uses.<socket>.<alias> para uma que um anexo traçou — com raiz no bloco que declarou o anexo, que pode ser o de um subsistema ou o de uma fronteira, e não o do próprio componente. Onde o socket foi declarado na Feature anexada, a mensagem nomeia o tipo de funcionalidade em vez do tipo de componente. Cada aresta com erro é comunicada como uma constatação própria, pelo que uma única compilação as nomeia todas.
Como corrigir: remover o bloco inject: da aresta e ler, em vez disso, os valores da dependência a partir de .context.uses.<alias>.provides.<name> na Recipe consumidora; ou, se a ligação se destinar a ser transparente, declarar os mecanismos de entrega que o socket permite na lista de permissões inject: da sua entrada de usesSchema.
Um socket que a entidade declarante nunca declarou é um caso diferente e não é aqui recusado: um socket ad hoc não traz nenhuma lista de permissões, pelo que não há nada fora do qual a aresta possa estar.
uses edge dictates a delivery mechanism outside the socket’s allowlist (Uma aresta dita um mecanismo de entrega fora da lista de permissões do socket)
Um bloco inject: numa aresta uses: nomeia um mecanismo de entrega que a lista de permissões inject: do socket não inclui. A lista de permissões é a declaração da entidade declarante sobre as formas de entrega a partir das quais o seu ponto de entrada consegue efetivamente ler os valores da dependência, pelo que um mecanismo fora dela entregaria valores que nada consome.
Todos os mecanismos que o bloco nomeia são verificados, e cada um que esteja fora da lista de permissões é comunicado, pelo que uma única compilação os nomeia todos em vez de um por execução.
Mensagem emitida. Primeiro vem a recusa, depois o mecanismo recusado, o socket, aquilo que esse socket permite e a entidade cuja declaração foi lida:
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. (o inject da aresta uses dita um mecanismo de entrega que o socket não permite (o mecanismo indicado, no socket indicado, que permite os mecanismos indicados, declarado no tipo de componente indicado). Ditar um dos mecanismos que o socket permite, ou alargar a lista de permissões de inject desse socket na entrada de usesSchema da entidade declarante.)
A constatação é posicionada na entrada escrita a que diz respeito, nos mesmos caminhos que a recusa acima nomeia. Onde o socket foi declarado na Feature anexada, a mensagem nomeia o tipo de funcionalidade em vez do tipo de componente.
Como corrigir: passar a usar um dos mecanismos permitidos, ou, se a entidade dever suportar o mecanismo de que precisa, alargar a lista de permissões inject: desse socket na sua entrada usesSchema do catálogo.
An inject: entry carries both a literal and a source key (Uma entrada de inject traz simultaneamente um literal e uma chave de origem)
Uma entrada inject: entrega uma de duas coisas: um literal, escrito sob value: — no próprio bloco de um componente, o único local onde um literal é entregue — ou uma chave lida do componente para o qual a ligação aponta, escrita sob from:. Uma entrada que traz as duas diz duas coisas ao mesmo tempo e não oferece nenhuma regra para escolher entre elas, pelo que é recusada em vez de deixar que uma das duas prevaleça silenciosamente.
Os esquemas de autoria admitem exatamente uma das duas, pelo que um documento lido de um ficheiro é recusado ao ser carregado. Esta é a verificação que está por trás daquela: lê todos os blocos inject: que o Aggregate e a Release trazem enquanto os dois documentos são resolvidos, pelo que um documento construído por outra via que não um ficheiro é ainda assim recusado antes de qualquer coisa ser construída a partir dele, em vez de ver um campo escolhido silenciosamente. Abrange os mesmos blocos que a verificação de forma mais abaixo.
Cada mecanismo de entrega que contém uma entrada com erro é comunicado como uma constatação própria, posicionada nesse mecanismo no documento que o escreveu — .spec.components.<component>.inject.env para o próprio bloco de um componente — e todos os da compilação são comunicados de uma vez. A constatação nomeia o mecanismo e depois o campo in: de cada entrada com erro na lista desse mecanismo.
Mensagem emitida:
inject entry carries both value: and from:; schema requires exactly one ("<mechanism>", "<in-1>", "<in-2>") (a entrada de inject traz os dois campos; o esquema exige exatamente um (com o mecanismo e as entradas indicados))
Como corrigir: abrir cada entrada que a mensagem nomeia e eliminar aquele dos dois de que ela não precisa. Manter from: onde o valor deve vir do componente para o qual a ligação aponta — nomeia uma chave que o provides: desse componente declara. Manter value: onde o valor é um literal que este lado fornece, no próprio bloco de um componente; numa ligação e no próprio bloco de uma Feature anexada um literal é recusado, pelo que aí se mantém from:.
An inject: entry on a connection carries a literal (Uma entrada de inject numa ligação traz um literal)
Uma ligação entrega ao componente consumidor aquilo que o componente para o qual aponta publica: cada entrada no bloco inject: da ligação nomeia sob from: uma das chaves provides: desse componente. Um literal escrito sob value: não nomeia nada que o destino publique, pelo que não tem lugar numa ligação, e a entrada é recusada em vez de descartada. Um literal que um componente entrega a si próprio pertence ao próprio bloco inject: do componente, onde value: é admitido.
Todas as ligações são verificadas, qualquer que seja o documento que as traçou: uma no próprio bloco uses: de um componente, uma que uma Feature anexada traça no Aggregate e uma que um anexo escrito na Release traça. É recusada antes de qualquer coisa ser renderizada, pelo que aggrega validate --release a comunica tal como aggrega build.
Cada entrada com erro é comunicada como uma constatação própria, posicionada na entrada da ligação no documento que a traçou — .spec.components.<component>.uses.<socket>.<alias> para a própria ligação de um componente, .spec.components.<component>.features.<attachment>.uses.<socket>.<alias> para uma que um anexo traça e, na Release, o mesmo caminho sob a entrada do anexo, como .spec.boundaries.<boundary>.components.<component>.features.<attachment>.uses.<socket>.<alias> — e todas as da compilação são comunicadas de uma vez. Uma constatação no Aggregate é classificada sob DEVELOPER_ERROR, uma na Release sob OPS_ERROR. A constatação nomeia o mecanismo e o campo in: da entrada.
Mensagem emitida:
inject entry on a connection carries value:; a connection delivers the target’s published keys, each named with from: ("<mechanism>", "<in>") (a entrada de inject numa ligação traz um literal; uma ligação entrega as chaves publicadas do destino, cada uma nomeada como origem (com o mecanismo e a entrada indicados))
Como corrigir: onde o valor for um que o destino publica, substituir value: por from: que nomeie essa chave provides:. Onde for um literal de que o componente consumidor precisa, mover a entrada para o próprio bloco inject: desse componente, cujos mecanismos são regidos pela lista de permissões spec.inject do seu tipo de Component.
An inject: entry on an attached Feature carries a literal (Uma entrada de injeção numa Feature anexada contém um literal)
O bloco inject: escrito numa Feature anexada entrega ao componente aquilo que a FeatureRecipe desse anexo publica: cada entrada nomeia uma das chaves que o provides: da FeatureRecipe publica, sob from:. Um literal escrito sob value: não nomeia nada que o anexo publique, pelo que nada chegaria ao componente sob o in: dessa entrada; a entrada é recusada em vez de ser construída e descartada. Um literal de que o componente precisa pertence ao próprio bloco inject: do componente, onde value: é admitido e entregue.
É verificado cada anexo em que um Aggregate escreve um bloco inject:: um no próprio bloco features: de um componente e um no bloco features: de um subsistema, que alcança cada componente que o subsistema contém — no Aggregate que a Release nomeia e em cada módulo que esse Aggregate importa sob aggregates:, a qualquer profundidade. Uma ligação que um anexo traça contém o seu próprio bloco inject:, e um literal aí cai na recusa de ligações descrita acima. Um anexo da Release não escreve nenhum bloco inject: próprio. A entrada é recusada antes de qualquer renderização, pelo que aggrega validate --release a comunica tal como aggrega build.
Cada entrada com erro é comunicada como uma constatação própria, registada como DEVELOPER_ERROR contra o Aggregate cujo documento escreveu o bloco — o próprio documento de um módulo, para um anexo escrito num módulo — e posicionada no mecanismo de entrega dentro do bloco do anexo nesse documento: .spec.components.<component>.features.<attachment>.inject.<mechanism>, ou .spec.subsystems.<subsystem>.features.<attachment>.inject.<mechanism> para o anexo de um subsistema. Todas as de um documento são comunicadas de uma só vez; as de um módulo importado são comunicadas assim que o Aggregate importador passa a verificação. A constatação nomeia o mecanismo e o in: da entrada. Uma entrada que contém tanto value: como from: é comunicada uma única vez, em «An inject: entry carries both a literal and a source key (Uma entrada de injeção contém tanto um literal como uma chave de origem)» acima.
Mensagem emitida:
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>") (uma entrada inject num anexo contém um literal; um anexo entrega as chaves que a sua FeatureRecipe publica, cada uma nomeada como chave de origem, e um literal pertence ao próprio bloco inject do componente)
Como corrigir: onde o valor for um que a FeatureRecipe do anexo publica, substituir value: por from: com o nome dessa chave provides:. Onde for um literal de que o componente precisa, mover a entrada para o próprio bloco inject: do componente, cujos mecanismos são regidos pela allowlist spec.inject do seu 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 (Uma entrega de inject não é uma lista de entradas)
Cada mecanismo de entrega num bloco inject: — env, file, arg ou um mecanismo nomeado ao lado deles — é uma lista de entradas, cada uma com in: e exatamente um de entre from: e value:. Um mecanismo que contenha qualquer outra coisa, como um mapeamento de nomes para chaves, não entrega nada que o compilador consiga ler, pelo que é recusado em vez de descartado. Um mecanismo escrito sem qualquer valor não entrega nada e não é recusado.
Os esquemas de autoria admitem apenas a lista, pelo que um documento lido de um ficheiro é recusado ao ser carregado, como documento que não corresponde ao esquema do seu tipo. Esta é a verificação que está por trás daquela: lê todos os blocos inject: que o Aggregate e a Release trazem enquanto os dois documentos são resolvidos, pelo que um documento construído por outra via que não um ficheiro é ainda assim recusado antes de qualquer coisa ser construída a partir dele, em vez de ver a entrega desaparecer. Abrange todos os blocos que qualquer um dos documentos traz: no Aggregate, o próprio de um componente, o de um anexo e os das ligações que qualquer um deles traça; na Release, os das ligações que os seus anexos traçam.
Cada mecanismo com erro é comunicado como uma constatação própria, posicionada nesse mecanismo no documento que o escreveu e nomeando o mecanismo, e todos os da compilação são comunicados de uma vez. As constatações do Aggregate são comunicadas antes das da Release.
Mensagem emitida:
inject delivery: shape must be a list of entries, each in: with exactly one of from: or value: ("<mechanism>") (entrega de inject: a forma tem de ser uma lista de entradas, cada uma com um destino e exatamente uma origem ou um literal (com o mecanismo indicado))
A posição é o caminho de chaves que o autor escreveu. No Aggregate, .spec.components.<component>.inject.<mechanism> para o próprio bloco de um componente, .spec.components.<component>.uses.<socket>.<alias>.inject.<mechanism> para um bloco numa das suas ligações e .spec.components.<component>.features.<attachment>… para o de um anexo, com .subsystems.<name> para cada subsistema em que um componente ou um anexo está declarado. Na Release, o bloco numa ligação que um anexo traça, através desse anexo — .spec.boundaries.<boundary>.features.<attachment>.uses.<socket>.<alias>.inject.<mechanism> para um anexado a toda a fronteira, .spec.boundaries.<boundary>.components.<component>.features.<attachment>… para um num componente, com .boundaries.<name> para cada fronteira aninhada e .aggregates.<module> para cada entrada de encaminhamento através da qual um componente é nomeado.
Como corrigir: escrever como lista cada mecanismo que a mensagem nomeia. Uma entrada DB_URL: host sob env: passa a ser - in: DB_URL com from: host quando host nomeia uma chave provides: — a do componente ligado numa ligação, a do próprio componente no seu próprio bloco — ou, no próprio bloco do componente, com value: host quando é um literal que este lado fornece.
The Feature filling an attachment slot does not satisfy the slot’s selector (A Feature que preenche um slot de anexo não satisfaz o seletor do slot)
Um Component declara pontos de associação com nome para as Features que espera, e um slot pode declarar um selector: que restringe os rótulos daquilo que o preencher. Um anexo associa um slot ao trazer o nome do slot; quando o faz, os rótulos da Feature que nomeia são comparados com essa restrição, e um preenchimento que não a satisfaça interrompe a compilação. Um slot que não declara nenhuma restrição aceita qualquer preenchimento.
Saber se um slot pode de todo ficar sem associação é uma questão diferente, com uma solução diferente, comunicada pela sua própria interrupção acima: esta pressupõe um preenchimento e pergunta se o preenchimento é admissível, pelo que um slot sem associação não lhe diz respeito.
Dois resultados são comunicados sob esta única condição, e a mensagem distingue-os pelo que diz o seu último valor. Um preenchimento que não satisfez a restrição nomeia a Feature cujos rótulos não corresponderam. Uma restrição que não pôde de todo ser lida nomeia, em vez disso, o motivo — uma expressão que o comparador de rótulos não conseguiu avaliar —, o que é um defeito na própria declaração do slot e não naquilo que lhe foi anexado.
Mensagem emitida, quando os rótulos do preenchimento não satisfizeram a restrição:
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. (seletor do slot de anexo não satisfeito (o seletor indicado, declarado no slot indicado, não satisfeito pelos rótulos da Feature que o preenche, o tipo de Feature indicado). Acrescentar aos rótulos da Feature os rótulos que o seletor do slot exige, ou preencher o slot com uma Feature que já os traga.)
e quando a própria restrição não pôde ser avaliada:
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. (seletor do slot de anexo não satisfeito (o seletor indicado, declarado no slot indicado, que não pôde ser avaliado: com o motivo indicado). Corrigir o seletor na declaração do slot na entidade de catálogo do componente.)
É posicionada na chave do preenchimento no documento que escreveu o preenchimento, e classificada sob o autor desse documento: o bloco features: do componente no Aggregate é um defeito do programador, e um preenchimento que só a Release faz — na sua entrada para o componente, ou numa fronteira que o contenha — é um defeito do operador, comunicado no próprio caminho da 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.
O mesmo preenchimento escrito no componente no Aggregate comunica [DEVELOPER_ERROR E0008] aggregate.yaml at .spec.components.app.features.identity.
Um slot que um socket declara — no featuresSchema de uma entrada de usesSchema — submete da mesma forma o preenchimento de cada ligação ao seu selector:. O anexo que uma ligação traz no slot é comparado com a restrição, e um preenchimento que esta não admita interrompe a compilação, nomeando o socket e a ligação além do 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. (seletor do slot de anexo não satisfeito (o seletor indicado, declarado no slot indicado, do socket indicado, preenchido na ligação indicada, não satisfeito pelos rótulos da Feature que o preenche, o tipo de Feature indicado). Acrescentar aos rótulos da Feature os rótulos que o seletor do slot exige, ou preencher o slot com uma Feature que já os traga.)
É posicionada na chave do anexo sob o features: dessa ligação, no documento que escreveu o preenchimento: a entrada da ligação do Aggregate, ou a entrada por aresta da Release para um preenchimento que só a Release faz.
Um seletor de slot que a gramática não consegue ler também é recusado antes de qualquer coisa preencher o slot.aggrega validate, sobre todo o catálogo ou sobre um único Component ou uma única Feature, lê todos os seletores de slot que o próprio documento da entidade declara — os slots do próprio Component, os slots que os seus sockets declaram e os slots de uma Feature — e recusa, sob esta mesma condição, aquele que a gramática não consegue ler, quer algo preencha o slot, quer não. A mensagem é a forma «não pôde ser avaliado» acima; um slot que um socket declara acrescenta o 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. (seletor de slot de anexo não satisfeito, declarado num slot de um socket, que não pôde ser avaliado. Corrija o seletor na declaração do slot no featuresSchema do socket, na entidade de catálogo do componente.)
Num slot de uma Feature, a correção indica antes a entidade de catálogo da Feature. Nada preencheu o slot, pelo que a falha é da entidade de catálogo: é classificada como CATALOG_ERROR e indica o ficheiro da entidade.
Como corrigir: para um preenchimento que não satisfez a restrição, anexar uma Feature cujos rótulos a satisfaçam — o seletor na mensagem indica que rótulos estão a ser pedidos — ou alargar o selector: do slot no Component que o declara. Onde a mensagem indica que a restrição não pôde ser avaliada, o defeito está na expressão do seletor: corrigi-la na declaração do slot do Component, ou na do socket.
An attachment written under another name fits a slot its component leaves empty (Um anexo escrito sob outro nome encaixa num slot que o seu componente deixa vazio)
A superfície de anexos própria de um Component é aberta: um anexo sob um nome que nenhum slot declara é um anexo livre, e é legal. Uma única forma nessa superfície provoca uma interrupção, porque é a forma que um preenchimento destinado a um slot assume quando é escrito sob o nome errado. A compilação é interrompida quando todas estas condições se verificam para um mesmo anexo:
está escrito no próprio componente — no próprio bloco features: do componente no Aggregate, ou na entrada da Release para esse único componente;
o seu nome não é um slot que o tipo do componente declare;
os rótulos da sua Feature satisfazem o selector: de um slot que o tipo declara;
nada associa esse slot no componente depois de todos os âmbitos terem sido combinados.
Deixado assim, esse anexo é um anexo livre enquanto o slot a que se destinava fica vazio — e um slot opcional deixado vazio produz uma compilação verde e não entrega nada. A regra aplica-se a qualquer Feature, não apenas a credenciais.
Tudo o resto na superfície continua livre. Um anexo cuja Feature não encaixa em nenhum slot declarado não interrompe a compilação; o mesmo acontece com um anexo adicional ao lado de um slot que algo já associa, desde que nenhum outro slot em que encaixe fique vazio. Um anexo que o componente herda de um subsistema ou de uma fronteira de Release nunca é avaliado, pelo que a forma partilhada — uma credencial anexada uma única vez num âmbito em que se encontram vários componentes, sem que nenhum componente preencha o slot — não interrompe a compilação. Um slot que não declara nenhum selector: não diz nada sobre a que Feature se destina, pelo que nenhum anexo lhe é submetido desta forma. Um anexo que uma ligação traz também não é avaliado aqui: os slots de um socket são um conjunto fechado, e qualquer outro nome numa ligação provoca uma interrupção sob «A connection carries an attachment under a name its socket declares no slot for (Uma ligação traz um anexo sob um nome para o qual o seu socket não declara nenhum slot)».
Mensagem emitida. Primeiro vem a frase da condição, depois o nome sob o qual o anexo foi escrito, o componente, a Feature que anexa e o slot vazio em que encaixa — depois o que fazer a esse respeito:
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. (um anexo escrito sob um nome que nenhum slot declara encaixa num slot que o seu componente deixa vazio (o anexo indicado, no componente indicado, que anexa a Feature indicada, a qual encaixa no slot vazio indicado). Anexá-lo com o nome do slot indicado para preencher o slot.)
Onde a Feature encaixa em mais de um slot vazio, a mensagem nomeia cada um, pela ordem em que o tipo do componente os declara, e deixa a escolha ao utilizador:
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. (um anexo escrito sob um nome que nenhum slot declara encaixa num slot que o seu componente deixa vazio (o anexo indicado, no componente indicado, que anexa a Feature indicada, a qual encaixa no slot vazio indicado e no outro slot vazio indicado). Anexá-lo sob o nome do slot que deve preencher.)
É posicionada na chave do anexo no documento que o escreveu, e classificada sob o autor desse documento. Um anexo no próprio bloco features: do componente no Aggregate é comunicado em .spec.components.<component>.features.<attachment> como um defeito do programador; um que só a Release escreveu, na sua entrada para o componente, é comunicado aí — sob a fronteira que nomeia o componente, .spec.boundaries.<boundary>.components.<component>.features.<attachment> — como um defeito do 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.
O próprio slot vazio é uma constatação separada onde é obrigatório, comunicada no componente no Aggregate sob «Required attachment slot not bound (Slot de anexo obrigatório sem associação)».
Em que difere do aviso de quase correspondência. O aviso descrito em «An attachment name is one edit from a declared slot (Um nome de anexo está a uma edição de distância de um slot declarado)» trata da forma como um nome é escrito: um nome a uma edição de distância de um slot cujo selector: a Feature do anexo não satisfaz, o que não interrompe a compilação e comunica uma advertência. Esta interrupção trata daquilo em que a Feature encaixa, seja qual for o nome: o nome pode ser qualquer um, e o slot em que encaixa tem de ter sido deixado vazio. Onde um nome está a uma edição de distância de um slot e a sua Feature encaixa de facto nesse slot, não é levantado nenhum aviso, e se o slot for deixado vazio esta interrupção é a única constatação comunicada.
Como corrigir: anexá-lo sob o nome do slot, para que preencha o slot — a mensagem nomeia o slot, ou cada candidato quando há vários. Se for realmente um anexo separado, preencher também o slot, uma vez que um anexo adicional é livre assim que cada slot em que encaixa está associado; ou, onde deva alcançar vários componentes, anexá-lo no subsistema ou na fronteira de Release em que estes se encontram. Se a Feature nunca deve preencher esse slot, restringir o selector: do slot no Component que o declara.
An attachment delivers a key another inject source already claimed (Um anexo entrega uma chave que outra fonte de inject já reivindicou)
Três superfícies de autoria entregam no canal de injeção de um componente através de um bloco inject:: o próprio bloco inject: do componente, os blocos inject: nas entradas do seu bloco de dependências e o bloco em cada Feature anexada a ele. Partilham um único espaço de chaves por mecanismo de entrega, pelo que uma chave que duas delas reivindicam é ambígua quanto ao valor que chega, e a compilação é interrompida em vez de deixar que uma superfície desloque silenciosamente outra. Uma Feature anexada também pode entregar de uma segunda forma, através do injectMapping da sua FeatureRecipe; essa via encontra o mesmo espaço depois de todos os blocos terem entregado, e é comunicada mais abaixo sob «Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Duas Features anexadas entregam uma mesma chave, a posterior através do injectMapping da sua FeatureRecipe)».
Esta condição é o lado desse espaço que cabe ao bloco do anexo. É comunicada quando o próprio bloco inject: de um anexo reivindica uma chave que uma entrega anterior já detém — a entrada mais acima, «Duplicate delivery key across inject sources (Chave de entrega duplicada entre as fontes de inject)», é a mesma regra lida a partir do lado escrito pelo programador, e juntas cobrem a reivindicação de todos os blocos.
É a ordem que decide quem colidiu. A primeira reivindicação sob uma chave é a que a detém, e as reivindicações posteriores são as comunicadas — pelo que um anexo cuja chave já está ocupada é informado disso, enquanto um anexo que reivindicou primeiro não é informado sobre um posterior que não deslocou nada. Uma reivindicação que não entregou nada deixa a chave livre e não participa em nada disto.
A constatação é posicionada na própria entrada do anexo dentro do bloco do componente, que é a posição a editar; a mensagem nomeia a chave e o mecanismo em cujo espaço de chaves esta se encontra. Cada chave em colisão é comunicada separadamente, pelo que um anexo que duplica duas chaves informa sobre ambas.
Mensagem emitida:
duplicate delivery key across attachment-inject and another inject source ("<key>", mechanism "<mechanism>") (chave de entrega duplicada entre o inject do anexo e outra fonte de inject (a chave indicada, o mecanismo indicado))
Como corrigir: nenhum dos lados é o infrator, e cabe-lhe agir sobre ambos. Mudar o nome da chave do lado que se controla — na maioria das vezes a própria entrada inject: do componente, uma vez que o mapeamento da Feature está escrito num documento de catálogo — ou descartar uma das duas entregas. Onde o anexo deve realmente fornecer o valor, remover a reivindicação escrita pelo programador, e não a do anexo. Note-se que o injectMapping da FeatureRecipe de uma Feature que escreve uma chave é uma via diferente e não é comunicado aqui: reescrever uma chave que o próprio bloco inject: do componente ou uma das suas ligações entregou é interceção e não é comunicado de todo, e escrever uma chave que outra Feature anexada entregou é comunicado sob a entrada seguinte.
Two attached Features deliver one key, the later through its FeatureRecipe’s injectMapping (Duas Features anexadas entregam uma mesma chave, a posterior através do injectMapping da sua FeatureRecipe)
Uma Feature anexada entrega no canal de injeção do seu componente por duas vias: o bloco inject: escrito no anexo e o injectMapping da sua FeatureRecipe, cuja saída nomeia a chave de entrega — muitas vezes a partir de um valor que o anexo traz, como a variável de ambiente escolhida para uma credencial. Quando duas Features anexadas chegam a uma mesma chave sob um mesmo mecanismo de entrega, e a posterior das duas lá chega através do seu mapeamento, a compilação é interrompida. Se continuasse, o componente leria o valor que por acaso fosse escrito em último lugar, pelo que uma credencial poderia ser apresentada no lugar de outra sem que nada na saída o indicasse.
Abrange cada Feature anexada, onde quer que tenha sido anexada: o próprio bloco features: do componente, um subsistema, uma fronteira de Release ou uma entrada de componente da Release, a expansão de uma anotação e a entrada features: de uma ligação. A anterior das duas entregas pode ser o mapeamento da outra Feature ou o próprio bloco inject: desta — a compilação comunica ambos os emparelhamentos sob esta única condição.
É a ordem que decide quem colidiu. Cada bloco inject: entrega antes de qualquer mapeamento ser renderizado, e os mapeamentos são renderizados numa única ordem fixa — a ordem pela qual o mapeamento de inject percorre as Features anexadas de um componente, descrita no pipeline de compilação — pelo que a primeira entrega sob uma chave é a que a detém, e a Feature posterior é a comunicada. Só a presença decide: os valores não são comparados, pelo que duas Features que entregam o mesmo valor sob uma mesma chave são comunicadas na mesma. Uma chave que a saída de um mapeamento não traz de todo não é uma entrega; uma chave que traz com um valor vazio é, porque o valor vazio substitui o que lá estava. Uma mesma chave sob dois mecanismos de entrega diferentes são duas chaves, não uma colisão.
O que não é comunicado. O injectMapping de uma FeatureRecipe que reescreve uma chave que o próprio bloco inject: do componente ou um dos blocos inject: das suas ligações entregou é interceção — uma Feature de encaminhamento a qualificar um host, uma proteção a redirecionar um upstream — e o valor do mapeamento substitui essa única entrada. O mapeamento de uma Feature que reescreve uma chave que o seu próprio bloco inject: entregou é essa Feature a transformar a sua própria entrega, e também não é comunicado.
A constatação é posicionada na própria entrada da Feature posterior — dentro do bloco features: do componente ou, para uma Feature que uma ligação traz, na sua entrada sob essa ligação no documento que a escreveu, como .spec.components.<component>.uses.<socket>.<alias>.features.<slot> no Aggregate. A mensagem nomeia a chave, o mecanismo de entrega e ambas as Features pelos nomes que trazem no componente; uma Feature que uma ligação traz é nomeada pelo alias da ligação e pelo slot que preenche, unidos por um ponto. Cada chave em colisão é comunicada separadamente.
Mensagem emitida:
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. (chave de entrega duplicada entre dois anexos: a FeatureRecipe de um anexo escreve uma chave de entrega que outro anexo já entregou. Dar a um dos dois anexos uma chave própria, ou anexar um a menos: a chave sob a qual este anexo entrega é escolhida pela sua FeatureRecipe, que pode ler os values e a infra do próprio anexo, e a do outro é escolhida da mesma forma ou pelo seu próprio bloco inject, quando entregou através de um. Uma Release define a infra de um anexo e nunca os seus values, pelo que, quando uma chave é escolhida por um valor, deve fazer-se esse anexo no Aggregate com o valor e continuar a fornecer o resto a partir da Release.)
Como corrigir: dar a uma das duas Features uma chave própria — para uma Feature de credencial, essa é normalmente a chave que os seus valores nomeiam — ou remover um dos dois anexos. Onde ambas devam fornecer uma mesma variável, decidir qual delas o componente deve ler e anexar apenas essa. Duas credenciais que uma Release anexa por si só chegam ambas sob a chave que a sua Feature nomeia por predefinição, porque uma Release não pode escrever os values de um anexo: anexar uma delas no Aggregate com o valor que nomeia a sua chave e indicar a sua origem a partir da Release na mesma entrada.
A component declares an inject mechanism the attached Feature maps nothing to (Um componente declara um mecanismo de inject para o qual a Feature anexada não mapeia nada)
A lista de permissões spec.inject de um Component pode nomear mecanismos de entrega para além dos mecanismos normais — um mecanismo que a própria lógica interna do componente compreende, e para o qual tudo o que nele entrega tem de produzir um valor. Quando uma Feature é anexada a um componente assim, o injectMapping da FeatureRecipe é o que indica sob que mecanismo cada valor que produz é entregue. Um mecanismo que o componente declarou e para o qual o mapeamento não produz nenhuma chave é uma entrega que silenciosamente nunca aconteceria, pelo que, em vez disso, a compilação é interrompida.
Um mapeamento que não diz nada sobre mecanismos não é um mapeamento que os exclui a todos. Uma FeatureRecipe cujo mapeamento é renderizado como um dicionário plano de entregas não afirma nada sobre mecanismos — essa é a forma habitual de escrever uma Feature que produz entregas como variáveis de ambiente —, e o mesmo acontece com um anexo que associa uma FeatureRecipe sem nenhum mapeamento a avaliar. Nenhum dos dois é comunicado aqui; esta condição diz respeito apenas a um mapeamento que nomeia mecanismos e omite um que o componente declarou.
Cada mecanismo não mapeado é uma constatação própria, pelo que um componente que declara dois, sem que um anexo mapeie nenhum deles, informa sobre ambos. A constatação é posicionada na entrada do anexo no seu próprio ficheiro, e nomeia também a FeatureRecipe — porque esse é o documento em que o mapeamento está escrito, e este encontra-se num local completamente diferente.
Mensagem emitida:
custom inject mechanism has no matching key in injectMapping output; add the mechanism’s key to the Recipe injectMapping ("<mechanism>", recipe "<featurerecipe>") (o mecanismo de inject personalizado não tem nenhuma chave correspondente na saída do injectMapping; acrescentar a chave do mecanismo ao injectMapping da Recipe (o mecanismo indicado, a FeatureRecipe indicada))
Como corrigir: a mensagem nomeia as duas metades. Acrescentar a chave do mecanismo ao injectMapping da FeatureRecipe para que a Feature produza um valor para ele, ou retirar o mecanismo da lista de permissões spec.inject do Component onde não se espera que nada entregue sob ele. Onde a FeatureRecipe pertence ao catálogo de outra pessoa, anexar uma Feature cujo mapeamento cubra o mecanismo é a terceira resposta.
An attached Feature’s injectMapping output cannot be read (A saída injectMapping de uma Feature associada não pode ser lida)
O injectMapping de uma FeatureRecipe é um template, e o que produz é lido como YAML: um dicionário com chaves por mecanismo de entrega — env, file, arg ou um mecanismo próprio do componente — ou um dicionário plano de entregas de ambiente. Quando a saída não pode ser lida como nenhum dos dois, nenhuma das suas chaves pode ser entregue, pelo que a compilação é interrompida em vez de renderizar o componente como se a Feature anexada não tivesse entregado nada. Uma credencial é o caso que mais importa: um componente que espera uma palavra-passe que nunca recebeu poderia, de outro modo, ser executado sem ela, e nada na saída o indicaria.
A causa habitual é um valor que o template escreveu entre aspas tal como está. Uma aspa dupla no seu interior termina prematuramente o escalar entre aspas, e uma barra invertida inicia um escape que o YAML pode não conhecer, pelo que um mapeamento que é renderizado corretamente para a maioria dos valores falha para aquele que contém um carácter assim — muitas vezes uma palavra-passe. Uma saída vazia, ou que é interpretada como um dicionário que não entrega nada, não é esta condição: não entrega nada, e é isso que diz.
O enquadramento acima da mensagem nomeia o componente que está a ser renderizado, depois o anexo pelo nome que traz no componente e a FeatureRecipe em que o mapeamento está escrito, como feature "<attachment>" (recipe "<featurerecipe>") injectMapping output. Abaixo da mensagem está o motivo pelo qual a saída não pôde ser lida — a linha e o que o YAML aí encontrou, como yaml: line 2: found unknown escape character. Onde o template lê um valor que um autor declarou sensível e o motivo depende do que esse valor contém, o motivo é omitido e uma frase que o indica aparece no seu lugar, pelo que a interrupção nunca cita o valor que estragou a saída. A compilação comunica a interrupção sob uma etiqueta CATALOG_ERROR, porque o mapeamento é escrito pelo autor da FeatureRecipe.
Mensagem emitida:
FeatureRecipe injectMapping output could not be read as a dictionary of deliveries (a saída injectMapping da FeatureRecipe não pôde ser lida como um dicionário de entregas)
Como corrigir: no injectMapping da FeatureRecipe, escrever cada valor através de toJson — {{ .values.key }}: {{ .values.origin | toJson }} —, que o escreve como uma cadeia JSON que o YAML volta a ler exatamente, sejam quais forem os caracteres que contenha. Onde a FeatureRecipe pertence ao catálogo de outra pessoa, o valor também pode ser alterado para não conter aspas duplas nem barras invertidas até que o mapeamento seja corrigido.
An attached Feature’s injectMapping output writes deliveries under a key nothing delivers (A saída injectMapping de uma Feature associada escreve entregas sob uma chave que nada entrega)
A saída do injectMapping de uma FeatureRecipe é integrada no canal de injeção do componente pelas suas chaves de primeiro nível. env, file e arg são entregues como esses mecanismos, e qualquer outra chave é entregue como um mecanismo próprio com esse nome, que a Recipe do componente lê em .context.inject.<name>. A vista all é diferente: é construída a partir dos mecanismos depois da integração, nunca integrada a partir de uma saída, pelo que os valores que um mapeamento escreve sob all: não chegam a nada. A saída continua a ser lida sem erros, pelo que, sem esta interrupção, uma compilação que lê esses valores de forma opcional é bem-sucedida sem eles — uma credencial escrita aí nunca chega ao componente, e nada na compilação nomeia o mapeamento que a perdeu.
Aplica-se onde quer que all: tenha pelo menos uma entrada, sozinho ou ao lado de outros mecanismos; os outros mecanismos na mesma saída não são o problema, e um all: escrito vazio não perde nada e não é comunicado. Um dicionário plano que por acaso tem uma chave chamada all com um único valor é uma entrega de ambiente chamada all, não esta condição.
A constatação é posicionada na entrada do anexo no seu próprio ficheiro, e nomeia a chave e a FeatureRecipe em que o mapeamento está escrito — porque esse é o documento a alterar, e encontra-se num local completamente diferente — juntamente com as chaves que uma saída pode ter. Cada uma dessas chaves é uma constatação própria. A compilação comunica-a sob uma etiqueta CATALOG_ERROR.
Mensagem emitida:
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") (a saída injectMapping da FeatureRecipe escreve uma chave que nenhum mecanismo de entrega do anfitrião lê (a chave all, a FeatureRecipe indicada e as chaves que uma saída pode ter))
Como corrigir: no injectMapping da FeatureRecipe, mover as entradas que estão sob all: para o mecanismo a partir do qual o componente as lê — normalmente env:, ou o nome do mecanismo que a Recipe do componente lê. Onde a FeatureRecipe pertence ao catálogo de outra pessoa, anexar em vez disso uma Feature cujo mapeamento entregue o valor.
Ao renderizar a saída
Depois de cada contrato ser validado, o compilador avalia templates Go nos valores de Component, nos blocos injectMapping de FeatureRecipe e nas fontes de Recipe e FeatureRecipe, e depois entrega o resultado ao renderizador.
provides: template references a non-self-contained root (O template de provides referencia uma raiz não autocontida)
O template provides: de uma Recipe referencia uma raiz fora do conjunto autocontido. O bloco provides é avaliado na avaliação dos provides, antes de o canal de inject ser hidratado e antes de as arestas entre nós serem percorridas, pelo que só pode referenciar dados que pertencem ao seu próprio nó: .context.instance_id, .context.rendered_name onde o fornecedor do nó comunica um, .values, .infra, os .locals resolvidos do nó e strings estáticas. A verificação é uma lista de permissões positiva, pelo que qualquer outra raiz provoca uma interrupção — .context.inject e .context.uses (entre nós), .context.annotations.*, .context.labels, .context.metadata e .metadata.* (dados ligados ao posicionamento ou à implementação que a superfície dos provides não expõe), e .attachment_name (a passagem dos provides de uma Recipe base não resolve nenhum anexo). Referenciar uma destas raízes interrompe a compilação de forma explícita em vez de renderizar silenciosamente um valor vazio.
.locals faz parte da superfície: os locals de um nó são resolvidos no preâmbulo da mesma etapa, antes dos seus provides, pelo que um template provides os lê e recebe valores resolvidos.
Mensagem emitida:
provides block references a root outside the self-contained set ("<expression>") (o bloco provides referencia uma raiz fora do conjunto autocontido (com a expressão indicada))
A interrupção é posicionada na Recipe que declara a entrada e na chave escrita dentro dela — .spec.provides.<name> —, pelo que nomeia o bloco a editar em vez do componente que associou a Recipe. Todas as entradas que saem da superfície são comunicadas na mesma compilação; onde há mais de uma, as constatações são agrupadas sob provides entries that reach outside the data they are evaluated against.
Como corrigir: reestruturar o template para que obtenha dados apenas dos pilares próprios da Recipe. Se o valor depender da saída de outro nó, essa dependência pertence ao bloco uses[].inject de um chamador, não aos provides do destino. Se o valor for calculado, colocar a expressão numa entrada locals: e lê-la a partir de provides — assim a expressão fica num único local. Se a intenção era alcançar o namespace de implementação (ou outros dados de posicionamento) para construir um host entre namespaces, publicar aqui o host simples e qualificá-lo do lado do consumidor com uma funcionalidade de encaminhamento — os provides do produtor não devem depender do local onde foi implementado.
O provides: de uma FeatureRecipe segue a mesma regra dos locals: os seus próprios locals: são resolvidos antes do seu provides:, pelo que uma entrada provides de uma FeatureRecipe também lê .locals.
locals: entry references a sibling defined later in the same block (Uma entrada de locals referencia uma entrada irmã definida mais abaixo no mesmo bloco)
Um bloco locals: é resolvido pela ordem em que as suas entradas são escritas, e uma entrada só lê uma entrada irmã definida acima dela. Uma referência direta .locals.<key> a uma entrada que o bloco define mais abaixo provoca uma interrupção: o compilador nunca ordena nem reordena o bloco para fazer a referência resolver-se, porque a saída emitida seguiria então uma inferência em vez daquilo que foi escrito. Sem a interrupção, a referência seria resolvida, pela política de chaves em falta, numa string vazia, pelo que um nome de host ou um nome de secret derivado perderia silenciosamente o segmento a partir do qual foi construído.
As duas resoluções de um bloco locals: decidem esta falha, e uma delas é a fixação. Um bloco é resolvido para dois fins diferentes: para que os templates próprios da Recipe o possam ler enquanto um artefacto é renderizado, e para que uma coordenada source: estruturada possa ser resolvida e o artefacto que nomeia possa ser fixado. A falha é decidida a partir da ordem de chaves declarada e do texto escrito, que é tudo aquilo de que precisa, pelo que as duas resoluções a alcançam e comunicam a mesma condição — aggrega pull, e uma compilação que preenche o lockfile, recusam o bloco exatamente como uma renderização o faz. Vale a pena conhecer duas consequências durante a escrita. O bloco inteiro é lido enquanto uma coordenada é resolvida, pelo que uma entrada fora de ordem provoca uma interrupção mesmo onde todos os campos source: são literais e não leem nenhum local. E uma Recipe cujo source: é uma string simples, ou que não declara nenhum source:, não resolve nenhuma coordenada, pelo que, nessa Recipe, a falha é comunicada quando a saída é renderizada.
Mensagem emitida, para uma entrada no próprio bloco locals: da Recipe de um componente. É posicionada na chave escrita dentro da Recipe, e todas as entradas com erro são comunicadas numa única compilação; onde há mais de uma, as constatações são agrupadas sob 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 (a entrada de locals referencia uma entrada irmã definida mais abaixo no mesmo bloco (com a expressão, a chave que nomeia, os locals resolvidos neste ponto e o componente através do qual foi alcançada indicados). definir a chave nomeada acima da entrada indicada no bloco locals)
Uma autorreferência é a mesma condição — a chave está declarada e não resolvida — e nenhuma reordenação a corrige, pelo que a mensagem o diz em vez da instrução de mover:
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 (a entrada de locals referencia uma entrada irmã definida mais abaixo no mesmo bloco (com a expressão, a chave que nomeia, os locals resolvidos neste ponto e o componente através do qual foi alcançada indicados). uma entrada de locals não se pode ler a si própria; calcular o valor diretamente a partir de .values e .infra)
Uma Recipe é associada por muitos componentes, pelo que um erro num bloco partilhado é comunicado uma vez por cada componente que o associa — e reached through the component é o que distingue essas constatações. Partilham uma posição, porque dizem todas respeito à mesma entrada escrita no mesmo documento; a posição é onde editar, e o nome do componente indica qual dos seus componentes cada constatação representa. As constatações não são fundidas numa só, porque fundi-las diria que algo está errado sem dizer que componentes isso alcança, e essa é a parte sobre a qual é preciso agir.
A mesma falha num bloco locals: que a receita de uma Feature declara é comunicada da mesma forma: posicionada na chave escrita dentro dessa receita, nomeada pelo componente onde o anexo se encontra, e agrupada com quaisquer entradas irmãs que tenham a mesma falha. Onde a receita está anexada em mais de um local, a falha é comunicada uma vez por cada um — cada anexo associa esse bloco de forma independente, pelo que cada um é uma ocorrência própria e não a repetição de uma só.
Onde essa forma comunica uma autorreferência, a sua cláusula de posição nomeia a própria entrada que faz a referência em vez de uma posterior, porque é aí que a chave se encontra.
Como corrigir: mover a entrada referenciada para cima de quem a lê. Reordenar um bloco locals: é uma alteração de comportamento sempre que uma entrada lê outra, pelo que a correção é exatamente a reordenação que a mensagem nomeia. Uma autorreferência — uma entrada que nomeia a sua própria chave — não pode ser corrigida por reordenação; em vez disso, calcular o valor diretamente a partir de .values e .infra, que é o que a mensagem diz em vez da instrução de mover.
locals: key does not exist (A chave de locals não existe)
Um template lê .locals.<key> para uma chave que o bloco locals: não declara de todo — um erro ortográfico, ou uma chave que foi renomeada ou removida. Todas as superfícies que leem o pilar desencadeiam esta interrupção: uma entrada locals:, um template provides:, um template source: de Recipe e a resolução de uma coordenada source: estruturada, que lê o bloco inteiro para fixar o artefacto que a coordenada nomeia. O pilar dos locals é um mapa aberto com chaves, pelo que uma chave desconhecida sob ele passa a verificação de raiz e, de outro modo, seria resolvida numa string vazia; a interrupção é o que impede esse valor vazio de chegar a um artefacto emitido.
Mensagem emitida, onde a referência com erro se encontra num template provides::
template references a key the locals block does not declare (Recipe <recipe> provides[<key>] references <expression>, the locals block declares no <referenced>, it declares <the keys it does declare>). correct the key name (o template referencia uma chave que o bloco locals não declara (a entrada de provides indicada da Recipe indicada referencia a expressão indicada, o bloco locals não declara a chave indicada, declara as chaves indicadas). corrigir o nome da chave)
Mensagem emitida, onde se encontra numa entrada locals: propriamente dita. Traz o componente através do qual o bloco foi associado, pelo motivo que a interrupção por ordenação acima expõe — um bloco partilhado é comunicado uma vez por cada componente que o associa, e é isto que separa essas constatações:
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 (o template referencia uma chave que o bloco locals não declara (com a expressão, a chave em falta, as chaves que o bloco declara e o componente através do qual foi alcançada indicados). corrigir o nome da chave)
Como corrigir: corrigir o nome da chave para um que o bloco declare; a mensagem lista-os. A interrupção é distinta da interrupção por ordenação acima porque os remédios diferem — nenhuma reordenação faz resolver uma chave que não existe.
A verificação lê o caminho para o qual uma referência se resolve em vez daquilo que foi digitado, pelo que um alias do bloco é seguido: uma chave alcançada através do ponto que um corpo with .locals volta a associar, ou através de uma variável associada a .locals, é verificada exatamente nos mesmos termos que a grafia direta e provoca uma interrupção da mesma forma, tal como uma chave lida do bloco entre parênteses — {{ (.locals).nope }} ou {{ ($.locals).nope }} — porque os parênteses produzem o próprio bloco e nada mais. Só uma grafia escapa à verificação: uma chave alcançada através de uma chamada cujo resultado o texto do template não consegue nomear — {{ index .locals "nope" }}, ou {{ (default dict .locals).nope }} — porque aquilo que uma chamada destas produz é decidido quando o template é executado e não por aquilo que está escrito. Uma chave ausente lida como campo do resultado de uma chamada destas — a forma (default dict .locals).nope — não provoca uma interrupção e renderiza o texto de marcador de posição do motor de templates <no value>. Uma chave ausente alcançada através de index provoca uma interrupção, mas como «A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)» mais abaixo, e não como esta verificação: index provoca uma interrupção em qualquer chave de mapa que o mapa não contenha. index continua, portanto, a ser a forma de alcançar uma chave cujo nome é ele próprio calculado, e um nome calculado que o bloco não declara continua a ser comunicado pela sua chave.
Template references a root the render context does not define (O template referencia uma raiz que o contexto de renderização não define)
Um template referencia uma raiz de nível superior — o primeiro segmento do caminho após o ponto inicial — que o seu contexto de renderização não define: um erro ortográfico como {{ .valeus.port }}, ou uma raiz que não existe na superfície que está a ser escrita. A verificação é uma lista de permissões positiva sobre nomes de raiz, e o conjunto admitido é derivado da própria forma do contexto de renderização em vez de mantido como uma lista separada ao lado dele, pelo que o conjunto que a compilação recusa e o conjunto que o contexto efetivamente entrega não podem divergir. O diagnóstico nomeia a referência com erro e lista as raízes que esse contexto define.
A interrupção ocorre de forma idêntica quer a referência esteja isolada quer esteja envolvida num fallback default, if, with ou range, e a forma envolvida é a que mais importa: um wrapper pode fornecer um fallback para uma chave ausente sob uma raiz definida, mas nunca para uma raiz ausente, pelo que, sem esta interrupção, a forma envolvida seria resolvida silenciosamente num valor vazio e deixaria a compilação terminar com êxito. Uma chave ausente sob uma raiz definida não é afetada e continua a seguir a política missingkey=zero para templates de valores descrita em «Missing template key — asymmetric policy (Chave de template em falta — política assimétrica)» mais abaixo, pelo que expressões idiomáticas de chave opcional como {{ .values.optional_field | default "fallback" }} continuam a funcionar.
A mesma interrupção abrange uma chave mal escrita um nível abaixo, sob um pilar cuja forma é declarada. Alguns pilares têm um conjunto de chaves que o compilador define: .context, .metadata, .inject, .workload e .boundary no contexto de renderização de Recipe e FeatureRecipe, e .manifest num template de caminho. Uma referência a uma chave que um desses pilares não define — {{ .context.nmae }}, {{ .metadata.typo }}, {{ .workload.containres }}, {{ .boundary.nmae }} — provoca uma interrupção exatamente como uma raiz errada, e o diagnóstico lista as chaves que esse pilar define. Nos templates próprios do anexo de uma Feature, .inject define uma chave adicional para cada mecanismo de entrega que o bloco inject: do próprio anexo nomeia, além de env, file, arg e all: um anexo que escreve um mecanismo vault_ref: é lido em {{ .inject.vault_ref.VAULT_PATH }}, e o diagnóstico lista .inject.vault_ref entre as chaves que .inject define. Um mecanismo que o anexo não nomeia provoca uma interrupção mesmo dentro de um if ou de um with, porque a referência é verificada antes de o template ser executado. Para ler um mecanismo que o anexo possa não nomear, é necessário protegê-lo: {{ with .inject }}{{ if hasKey . "vault_ref" }}{{ index . "vault_ref" "VAULT_PATH" }}{{ end }}{{ end }}. Com o par protegido, a compilação conclui-se quer o anexo nomeie o mecanismo quer não, e quer escreva um bloco inject: quer não escreva nenhum — nesse caso .inject não contém nada, pelo que o with salta o seu corpo, enquanto hasKey aplicado diretamente a .inject provocaria uma interrupção num valor que não é um mapa. Dentro da proteção, index continua a provocar uma interrupção numa chave que o mecanismo nomeado não contém. Outros pilares são abertos, porque aquilo que contêm são dados com chaves e não um conjunto que o compilador declara — entre eles .values, .infra, .locals, .provides, .features e .steps no contexto de renderização, e .parameters e .parent_boundary num template de caminho. Um pilar aberto aceita qualquer chave. Uma chave ausente sob um pilar aberto não é esta interrupção — segue a política de chaves em falta da superfície descrita em «Missing template key — asymmetric policy (Chave de template em falta — política assimétrica)» mais abaixo, pelo que {{ .values.optional_field | default "fallback" }} e qualquer outra expressão idiomática de chave opcional continuam a funcionar.
Quais pilares são declarados e quais são abertos é uma propriedade da superfície, e não algo que um template possa influenciar: o compilador lê-o a partir da forma do contexto de renderização que está prestes a entregar. É isso que permite que a interrupção por erro ortográfico e a renderização da chave opcional coexistam no mesmo template.
Uma superfície pode também restringir uma chave que o seu pilar define noutros casos, e uma comunicação dessas não é um erro ortográfico. Onde uma chave traz uma resposta sem significado — ou que pertence a outro nó — numa superfície específica, essa superfície recusa a referência em vez de a resolver para a coisa errada, e o diagnóstico lista as chaves que define. Dois casos a conhecer, ambos {{ .context.rendered_name }}. Nos templates próprios de um anexo de Feature, a chave traz o nome do componente anfitrião tal como o próprio fornecedor do anfitrião o comunica, pelo que é recusada no anexo de um anfitrião cujo fornecedor não comunica nenhum nome — um anfitrião que posiciona sozinho um conjunto de artefactos, ou um que renderiza através de um fornecedor que não deriva tal nome — e admitida em qualquer outro anfitrião. {{ .context.instance_id }} é admitida nessa superfície e nomeia o componente anfitrião para o qual o anexo está a ser resolvido, que é o nome que os recursos próprios do anfitrião recebem num anfitrião desses. Nas entradas locals: de uma Recipe, a chave é recusada independentemente daquilo que o fornecedor do nó comunique: um local partilha o seu contexto com o template source: da Recipe, e o facto de o nó fornecer ou não uma fonte é uma das coisas de que o nome depende, pelo que o nome não é aí oferecido. O diagnóstico lista .context.instance_id como a única chave que .context aí define; o nome renderizado deve ser lido numa entrada provides: ou num template inline. Consultar ../templates/rendered-resource-names.md para saber o que cada uma das duas chaves nomeia e onde cada uma pode ser lida.
Mensagem emitida quando a própria raiz não 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>) (o template referencia uma raiz que o contexto de renderização não define (o template indicado referencia o caminho indicado, o contexto de renderização define as raízes indicadas))
E quando a raiz está correta, mas uma chave sob um pilar declarado não está:
template references a root the render context does not define (template <template-name> references <dotted-path>, <pillar> defines <the keys that pillar defines>) (o template referencia uma raiz que o contexto de renderização não define (o template indicado referencia o caminho indicado, o pilar indicado define as chaves indicadas))
Como corrigir: corrigir a referência para uma das que o diagnóstico lista — a maioria das comunicações é um erro ortográfico em .values, .infra ou .context, ou numa chave sob .context ou .metadata. Remover o wrapper de fallback não elimina a interrupção, e acrescentar um nunca a suprimiu; o wrapper apenas escondia qual a referência que estava errada. Se os dados pertencerem realmente a outro nó, chegam a este template pelo canal de inject — cablá-los com uma entrada uses[].inject no consumidor e lê-los a partir de .context.inject — e não por uma raiz própria.
A verificação abrange todas as superfícies de template que o renderizador avalia, cada uma em relação ao conjunto de referências que a sua própria superfície define: valuesMapping, injectMapping e workload de Recipe e FeatureRecipe, corpos de artifacts:, entradas provides: e locals:, source:, corpos when: e with: de passos de pipeline, assertions:, os templates value: de self-inject ao nível do componente num Aggregate e os templates de caminho das fronteiras da Release (directory: / subDirectory:). Duas dessas superfícies nomeiam algumas recusas com um diagnóstico próprio, porque o erro que descrevem é mais específico do que «esta referência não existe»: um template de caminho que tenta alcançar uma variável que não lhe é fornecida é abrangido por «Path-template references a variable outside the allowlist (O template de caminho referencia uma variável fora da lista de permissões)» mais abaixo, e uma FeatureRecipe de âmbito de fronteira que tenta alcançar um pilar por componente, por «FeatureRecipe template references a field outside its scope’s allowlist (O template de FeatureRecipe referencia um campo fora da lista de permissões do seu âmbito)». Tudo o resto que essas duas superfícies recusam — incluindo uma chave mal escrita sob um pilar que admitem — comunica esta interrupção, pelo que nenhum diagnóstico diz que a referência é algo que ela não é.
An artifacts: template reads a pillar the Recipe does not declare (Um template de artifacts lê um pilar que a Recipe não declara)
O template de uma entrada artifacts: lê .workload, ou uma chave abaixo dele, numa Recipe que não declara nenhum workload:; ou lê .source, ou uma chave abaixo dele, numa Recipe que não declara nenhum source:. Os dois pilares estão sempre presentes no contexto de renderização dos artefactos — são raízes que a superfície define —, pelo que a referência está bem formada e a interrupção diz respeito à ausência da declaração e não a uma referência errada. Uma Recipe que renderiza um Deployment a partir da sua carga de trabalho sintetizada e uma Recipe que renderiza um chart a partir de uma fonte são formas diferentes, e um corpo artifacts: escrito para uma delas tenta alcançar um pilar que a outra nunca preenche.
A verificação é executada antes de a entrada ser avaliada, e é essa ordem que torna a comunicação útil. Um pilar ausente chega ao template como um valor vazio, pelo que, deixada à avaliação, a compilação ou não inseriria nada no ficheiro emitido, ou falharia com aquilo que o motor de templates diz sobre a leitura de uma chave a partir de nada — e nenhuma das duas coisas nomeia o pilar ou a declaração em falta. Recusar primeiro permite que a interrupção nomeie a expressão exata que tentou alcançar o pilar, citada tal como foi escrita.
Um source: que está declarado mas cuja renderização resulta numa string vazia é lido como nenhuma fonte, porque aquilo que a verificação lê é a fonte depois de o seu próprio template ter sido avaliado. É o mesmo valor a partir do qual o fornecedor renderiza em seguida, pelo que uma Recipe cujo source: se resolveu em nada também não tem fonte a oferecer a um corpo artifacts:.
Mensagem emitida, numa única forma onde quer que a entrada artifacts: tenha sido escrita. O que varia não é a frase, mas as legendas que se lhe seguem, que indicam qual o documento que contém a entrada.
Todas as referências com erro no template são nomeadas, pelo que um corpo que tenta alcançar dois pilares ausentes comunica ambos e não apenas aquele que surgiu primeiro. Cada referência é comunicada no documento que declara a entrada, citada tal como foi escrita e com a legenda da saída a que pertence:
artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>) (o template de artefacto referencia um pilar que a Recipe não declara (com a expressão e o artefacto indicados))
A expressão nomeia o pilar no seu primeiro segmento, e é isso que indica qual a declaração em falta: .source.chart tenta alcançar source:, e .workload.containers, workload:.
Uma entrada que a Recipe própria de um componente declara é comunicada no bloco artifacts: dessa Recipe.
Uma entrada que uma FeatureRecipe declara — anexada a um componente como funcionalidade, ou declarada numa fronteira — é verificada em relação aos pilares que essa FeatureRecipe declara e não aos do componente anfitrião, é comunicada no bloco artifacts: da FeatureRecipe e traz uma legenda adicional que nomeia o anexo que a associa:
artifact template references a pillar the Recipe does not declare (<expression>, artifact <output-name>, attachment <attachment-name>) (o template de artefacto referencia um pilar que a Recipe não declara (com a expressão, o artefacto e o anexo indicados))
A legenda do anexo é aquilo que a posição não consegue dizer sozinha: um componente pode ter vários anexos, e um anexo declarado numa fronteira alcança todos os componentes que a fronteira contém. A própria frase nomeia uma Recipe em ambos os caminhos; são a posição e a legenda do anexo, em conjunto, que indicam qual o documento a abrir.
Onde um template nomeia várias referências, cada uma recebe uma comunicação própria sob uma linha que nomeia a entrada que partilham, e essa linha nomeia também o documento:
artifact <output-name> references pillars its Recipe does not declare (o artefacto indicado referencia pilares que a sua Recipe não declara)
artifact <output-name> references pillars the FeatureRecipe attachment <attachment-name> binds does not declare (o artefacto indicado referencia pilares que a FeatureRecipe associada pelo anexo indicado não declara)
Cada uma destas comunicações traz a mesma condição de interrupção, seja qual for o documento a que diz respeito, pelo que tudo aquilo que faz correspondência com a condição, e não com o texto, não vê qualquer diferença entre elas.
Como corrigir: declarar o pilar que o template lê, ou deixar de o ler. Declará-lo é a correção quando o corpo artifacts: pertence a essa forma de Recipe — acrescentar o workload: que as referências do template a contentores, portas ou volumes esperam, ou o source: cujo caminho de chart ou de módulo ele interpola. Remover a referência é a correção quando o corpo foi escrito para uma Recipe diferente e reutiliza um fragmento que aqui não se aplica; onde o valor vem realmente de outro lado, publicá-lo através do provides: do nó produtor e lê-lo a partir do canal de inject em vez de tentar alcançar um pilar que esta Recipe não preenche. Proteger a referência com um wrapper de fallback não elimina a interrupção — falta o pilar, não a chave abaixo dele —, e mover a referência para outra entrada da mesma Recipe também não, porque todas as entradas de um mesmo bloco artifacts: são avaliadas em relação aos mesmos pilares.
Esta interrupção é distinta de «Template references a root the render context does not define (O template referencia uma raiz que o contexto de renderização não define)» acima, e vale a pena distinguir as duas porque os remédios diferem. Aquela ocorre numa raiz que a superfície não define de todo, ou numa chave mal escrita sob um pilar cuja forma é fixa — {{ .workload.containres }} numa Recipe que de facto declara uma carga de trabalho. Esta ocorre numa referência corretamente escrita a um pilar que simplesmente não existe.
A template reads a rendered name the node’s provider does not report (Um template lê um nome renderizado que o fornecedor do nó não comunica)
Um template lê {{ .context.rendered_name }} — o nome que o fornecedor associado dá à saída que renderiza para o nó, a partir de uma fonte fornecida pelo autor ou de uma carga de trabalho que sintetiza — num nó cujo fornecedor não comunica nenhum nome desse tipo. A referência está bem formada e a chave é uma das que o contexto de renderização define; o que falta é uma resposta para este nó.
A recusa existe porque a alternativa é pior do que uma interrupção. O nome chega a um template como uma string simples, pelo que um nó sem nome faria desaparecer a referência na renderização e emitiria um endereço com um segmento a menos — .svc.cluster.local onde se pretendia um nome de host — com código de saída zero, sem nada para ler na compilação. Esse artefacto é implementado, e aquilo que nomeia não existe. Recusar antes de qualquer avaliação comunica, em vez disso, a falha no template que o autor escreveu.
Se o fornecedor de um nó comunica um nome desse tipo é definido pela associação da Recipe, antes de qualquer avaliação, pelo que aqui nada é adivinhado.
Duas comunicações, e qual delas se recebe depende do nó e não do local onde a referência foi escrita. Um nó que não fornece nenhuma fonte própria, sob um fornecedor que não comunica nenhum nome para ele, tem os seus recursos nomeados segundo a sua identidade, pelo que existe um valor correto e a comunicação nomeia-o. Um nó que fornece de facto uma fonte, sob um fornecedor que não deriva nenhum nome para ele, não tem substituto — e oferecer aí a identidade levaria a um valor que não nomeia nenhum dos recursos desse nó, pelo que a comunicação o diz em vez disso.
Mensagem emitida, onde o nó não fornece nenhuma fonte própria:
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 (o template lê o nome que o destino dá aos recursos que renderiza para o nó, e o fornecedor deste nó não comunica nenhum nome desse tipo; um template conforme lê um valor que o próprio fornecedor do nó fornece (com a chave e o fornecedor indicados). ler antes a chave indicada: este nó não fornece nenhuma fonte própria, pelo que os seus recursos são nomeados segundo a identidade do nó)
E onde fornece de facto uma fonte, sob um fornecedor que não deriva nenhum nome desse tipo:
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 (o template lê o nome que o destino dá aos recursos que renderiza para o nó, e o fornecedor deste nó não comunica nenhum nome desse tipo; um template conforme lê um valor que o próprio fornecedor do nó fornece (com a chave e o fornecedor indicados). escrever um valor que não dependa de um nome que este destino deriva: não comunica nenhum para a saída que renderiza a partir de uma fonte fornecida, pelo que aqui não há nada desse tipo para ler)
Onde a referência se encontra num template que não é uma entrada provides:, a comunicação nomeia também o campo em que foi escrita — field "valuesMapping", field "artifacts[probe.tf.json]" —, porque a chave de uma entrada artifacts: é um nome de ficheiro de saída e contém o carácter com que a posição separa os seus próprios segmentos, pelo que a posição para no bloco que contém a entrada.
Que templates abrange: todos os templates que uma Recipe escreve inline — as suas entradas provides:, o seu valuesMapping:, o seu corpo workload:, cada entrada artifacts: e o with: e o when: de cada passo de pipeline. Uma superfície de template fica de fora: uma entrada valuesMapping:, workload: ou artifacts: fornecida através de $import: — quer o import nomeie um ficheiro local, quer uma entrada de biblioteca — não traz nenhum texto na Recipe até a renderização a resolver, pelo que uma referência dentro de um corpo desses é renderizada como um valor vazio em vez de provocar uma interrupção.
Como corrigir: ler a chave que a comunicação nomeia. Onde a saída do nó é algo construído para ele sob um fornecedor que não comunica nenhum nome — uma carga de trabalho sintetizada, um conjunto de artefactos posicionado —, {{ .context.instance_id }} é o nome que esses recursos efetivamente recebem, e é o valor certo e não um fallback. Onde o nó fornece um chart ou módulo próprio e a comunicação não oferece nenhum substituto, o nome que se tentava alcançar não é um que esse fornecedor derive: publicar algo que não dependa dele, ou nomear o recurso na fonte fornecida e voltar a ler esse nome a partir de um valor que o próprio utilizador define. ../templates/rendered-resource-names.md expõe quais os fornecedores que comunicam um nome e, para cada um dos restantes, por que razão não existe nenhum a comunicar.
A template reads its callers’ render facts without declaring it (Um template lê os factos de renderização dos seus chamadores sem o declarar)
Um template numa FeatureRecipe anexada a um componente lê render_facts sob .context.used_by — aquilo que os componentes que se ligam ao anfitrião do anexo comunicaram sobre as suas próprias renderizações — e a FeatureRecipe não define readsCallerRenderFacts: true.
A chave é o que decide quando o anexo é renderizado. Sem ela, o anexo é renderizado logo a seguir ao componente a que está anexado, e um componente que se liga e que surge mais tarde na ordem da compilação ainda não foi renderizado nesse momento, pelo que aquilo que emitiu não pode estar lá para ser lido. Recusar o template antes de qualquer renderização comunica a declaração em falta no campo que foi escrito, em vez de uma compilação cujo template lê aquilo que alguns dos seus chamadores emitiram e não os restantes.
Mensagem emitida:
template reads its callers’ render facts, but the FeatureRecipe does not set readsCallerRenderFacts (<reference>, written in <field>) (o template lê os factos de renderização dos seus chamadores, mas a FeatureRecipe não define readsCallerRenderFacts (com a referência e o campo em que está escrita indicados))
A referência é citada relativamente à ligação de onde foi lida — .render_facts, ou .render_facts.<name> —, porque um template lê os chamadores uma ligação de cada vez, dentro de {{ range .context.used_by }} ou a partir de uma ligação que escolhe. O campo nomeia o bloco em que o template foi escrito: valuesMapping, workload ou artifacts[<output-name>]. Um with: ou when: de um passo de pipeline que leia os mesmos factos é comunicado, em vez disso, pela entrada seguinte, seja o que for que a FeatureRecipe defina, porque definir a chave não permitiria a um passo lê-los. Onde vários campos leem os factos, cada um recebe uma comunicação própria sob uma linha que nomeia aquilo que partilham:
attachment templates reading their callers’ render facts without declaring it (templates de anexo que leem os factos de renderização dos seus chamadores sem o declarar)
Como corrigir: definir readsCallerRenderFacts: true no spec da FeatureRecipe. Isso renderiza os seus anexos depois de todos os componentes terem sido renderizados e não altera mais nada naquilo que renderizam — consultar a página da entidade FeatureRecipe. A chave é o contrato, e esta interrupção apenas ajuda a encontrar um template que visivelmente precisa dela: a verificação lê o template tal como está escrito, pelo que uma referência construída enquanto o template é executado, ou uma escrita em conteúdo importado de um ficheiro ou de uma biblioteca, não provoca uma interrupção — definir mesmo assim a chave numa FeatureRecipe desse tipo. Um template que leia um campo chamado render_facts a partir de outra lista ao lado de .context.used_by também provoca uma interrupção, tal como um que leia os factos próprios do seu anfitrião como .render_facts dentro de {{ with .context }} ao lado dela — escrever os do anfitrião por extenso como .context.render_facts, que nunca é tomado pelos dos chamadores; definir a chave elimina ambos os casos sem outro custo além da renderização posterior.
Uma FeatureRecipe que renderiza uma única vez por fronteira (executionScope: boundary) não é verificada aqui: os templates que produzem os seus recursos não têm nenhum .context para ler, e uma referência a ele é recusada, em vez disso, como um campo fora da lista de permissões do seu âmbito.
A pipeline step reads its callers’ render facts (Um passo de pipeline lê os factos de renderização dos seus chamadores)
O with: ou o when: de um passo de pipeline, numa FeatureRecipe anexada a um componente, lê render_facts sob .context.used_by — aquilo que os componentes que se ligam ao anfitrião do anexo comunicaram sobre as suas próprias renderizações.
Um passo de pipeline nunca vê essas ligações. Um passo pode reescrever os documentos próprios do componente anfitrião, e a saída própria de um componente mantém-se igual independentemente de quem se liga a ele, pelo que os templates de um passo são avaliados sem .context.used_by — para qualquer FeatureRecipe, quer defina quer não readsCallerRenderFacts: true. Essa chave decide quando o anexo é renderizado, nunca aquilo que um passo vê. Um passo que lesse os factos dos seus chamadores não leria, portanto, nada, e a compilação é interrompida antes de qualquer renderização, em vez de renderizar essa leitura como um valor vazio.
Mensagem emitida:
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>) (o passo de pipeline lê os factos de renderização dos seus chamadores, mas um passo de pipeline não lê os componentes que se ligam ao seu anfitrião; lê apenas os factos de renderização próprios do anfitrião (com a referência e o campo em que está escrita indicados))
A referência é citada relativamente à ligação de onde foi lida — .render_facts, ou .render_facts.<name> — como na entrada acima, e o campo nomeia o passo pelo seu id: pipeline[<step>].with ou pipeline[<step>].when. Onde vários passos leem os factos, cada um recebe uma comunicação própria sob uma linha que nomeia aquilo que têm em comum:
pipeline steps reading their callers’ render facts (passos de pipeline que leem os factos de renderização dos seus chamadores)
Como corrigir: num passo, ler os factos de renderização próprios do anfitrião em .context.render_facts, escrito por extenso — provêm da renderização própria do anfitrião, pelo que lê-los não faz nada depender de quem se liga a ele. Ler, em vez disso, os factos dos chamadores nos templates que produzem os recursos próprios do anexo — o seu valuesMapping:, workload: ou artifacts: — com readsCallerRenderFacts: true definido, como descreve a página da entidade FeatureRecipe. Definir apenas a chave não elimina esta interrupção. A verificação lê o template tal como está escrito, com os limites que a entrada acima descreve: uma referência construída enquanto o template é executado, ou uma escrita em conteúdo importado de um ficheiro ou de uma biblioteca, não provoca uma interrupção, e um passo que lê um campo chamado render_facts de outra lista ao lado de .context.used_by, ou os factos próprios do seu anfitrião como .render_facts dentro de {{ with .context }} ao lado dela, também provoca uma interrupção.
Uma FeatureRecipe que é renderizada uma única vez para uma fronteira (executionScope: boundary) não é verificada aqui, pelo motivo que a entrada acima indica.
A template reads its targets’ render facts without declaring it (Um template lê os factos de renderização dos seus destinos sem o declarar)
Um template numa FeatureRecipe anexada a um componente lê render_facts sob .context.uses — aquilo que os componentes aos quais o anfitrião do anexo está cablado comunicaram sobre as suas próprias renderizações — e a FeatureRecipe não define readsTargetRenderFacts: true.
A chave decide duas coisas. Faz com que o anexo seja renderizado depois de todos os componentes terem sido renderizados: sem ela, o anexo é renderizado logo a seguir ao componente ao qual está anexado, e um destino que vem mais tarde na ordem da compilação ainda não foi renderizado nesse momento. E é ela que coloca os factos de cada destino nas ligações que o anexo lê: sem ela, nenhuma entrada de .context.uses traz .render_facts. Recusar o template antes de qualquer renderização comunica a declaração em falta no campo que foi escrito, em vez de uma compilação cujo template não lê nada onde esperava os factos de um destino.
Mensagem emitida:
template reads the render facts of a component its host is wired to, but the FeatureRecipe does not set readsTargetRenderFacts (<reference>, written in <field>) (o template lê os factos de renderização de um componente ao qual o seu anfitrião está cablado, mas a FeatureRecipe não define readsTargetRenderFacts (com a referência e o campo em que está escrita indicados))
A referência é a que o template escreveu: por extenso sob o alias de uma ligação — .context.uses.<alias>.render_facts, ou .context.uses.<alias>.render_facts.<name> — ou, onde o template lê as ligações uma de cada vez, dentro de {{ range .context.uses }}, {{ with .context.uses.<alias> }} ou a partir de uma ligação que escolhe, relativamente a essa ligação: .render_facts, ou .render_facts.<name>. O campo nomeia o bloco em que o template foi escrito: valuesMapping, workload ou artifacts[<output-name>]. Um with: ou when: de um passo de pipeline que lê os mesmos factos é comunicado, em vez disso, pela entrada seguinte, seja o que for que a FeatureRecipe defina. Onde vários campos leem os factos, cada um recebe uma comunicação própria sob uma linha que nomeia aquilo que têm em comum:
attachment templates reading the render facts of the components their host is wired to, without declaring it (templates de anexo que leem os factos de renderização dos componentes aos quais o seu anfitrião está cablado, sem o declarar)
Como corrigir: definir readsTargetRenderFacts: true no spec da FeatureRecipe — readsCallerRenderFacts: true não elimina esta interrupção, uma vez que coloca factos nos componentes que se ligam ao anfitrião e não naqueles aos quais este está cablado. Isso renderiza os seus anexos depois de todos os componentes terem sido renderizados, coloca os factos de cada destino na respetiva ligação e não altera mais nada naquilo que renderizam — consultar a página da entidade FeatureRecipe. A chave é o contrato, e esta interrupção apenas ajuda a encontrar um template que visivelmente precisa dela: a verificação lê o template tal como está escrito, pelo que uma referência construída enquanto o template é executado, ou uma escrita em conteúdo importado de um ficheiro ou de uma biblioteca, não provoca uma interrupção — definir a chave numa FeatureRecipe dessas mesmo assim. Um template que lê .context.uses de alguma forma e também lê um campo chamado render_facts de outro valor — entre eles os factos de um chamador dentro de {{ range .context.used_by }} — também provoca uma interrupção; definir a chave, e também readsCallerRenderFacts onde o template lê os factos dos seus chamadores.
Uma FeatureRecipe que é renderizada uma única vez para uma fronteira (executionScope: boundary) não é verificada aqui, pelo motivo que a entrada sobre os chamadores acima indica.
A pipeline step reads its targets’ render facts (Um passo de pipeline lê os factos de renderização dos seus destinos)
O with: ou o when: de um passo de pipeline, numa FeatureRecipe anexada a um componente, lê render_facts sob .context.uses — aquilo que os componentes aos quais o anfitrião do anexo está cablado comunicaram sobre as suas próprias renderizações.
Um passo lê as ligações que o seu anfitrião estabelece, tal como a Recipe própria do anfitrião as lê, e nunca os factos de renderização dos destinos delas — para qualquer FeatureRecipe, quer defina quer não readsTargetRenderFacts: true. Um passo pode reescrever os documentos próprios do componente anfitrião, e a renderização própria do anfitrião lê aquilo que os seus destinos publicam, nunca aquilo que emitiram, pelo que os templates de um passo são avaliados sem esses factos. Um passo que os lesse não leria, portanto, nada, e a compilação é interrompida antes de qualquer renderização, em vez de renderizar essa leitura como um valor vazio.
Mensagem emitida:
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>) (o passo de pipeline lê os factos de renderização de um componente ao qual o seu anfitrião está cablado, mas um passo de pipeline lê apenas os factos de renderização próprios do anfitrião (com a referência e o campo em que está escrita indicados))
A referência é citada como na entrada acima, e o campo nomeia o passo pelo seu id: pipeline[<step>].with ou pipeline[<step>].when. Onde vários passos leem os factos, cada um recebe uma comunicação própria sob uma linha que nomeia aquilo que têm em comum:
pipeline steps reading the render facts of the components their host is wired to (passos de pipeline que leem os factos de renderização dos componentes aos quais o seu anfitrião está cablado)
Como corrigir: num passo, ler os factos de renderização próprios do anfitrião em .context.render_facts, escrito por extenso. Ler, em vez disso, os factos dos destinos nos templates que produzem os recursos próprios do anexo — o seu valuesMapping:, workload: ou artifacts: — com readsTargetRenderFacts: true definido, como descreve a página da entidade FeatureRecipe. Definir apenas a chave não elimina esta interrupção. A verificação lê o template tal como está escrito, com os limites que a entrada acima descreve.
Uma FeatureRecipe que é renderizada uma única vez para uma fronteira (executionScope: boundary) não é verificada aqui, pelo motivo que a entrada sobre os chamadores acima indica.
Cross-node type safety violation via selector: (Violação da segurança de tipos entre nós através de selector)
Uma única interrupção abrange as duas expressões de rótulos que um autor de catálogo escreve para restringir aquilo que pode ser cablado ou anexado, porque ambas falham da mesma forma: um conjunto de rótulos que não satisfaz uma expressão que uma entidade do catálogo declarou.
Uma aresta uses: cujo destino não satisfaz o selector: do seu socket. Um socket usesSchema declara um campo selector: que exclui o Component de destino ligado na outra extremidade da aresta. O seletor é a forma de o autor do catálogo dizer «este socket só aceita destinos cujos rótulos correspondam a esta expressão»; uma aresta que satisfaz a procura pelo nome do socket, mas não a expressão do seletor, é uma violação da segurança de tipos.
Mensagem emitida:
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. (violação de seletor (a expressão indicada, declarada no socket indicado, não é satisfeita pelos rótulos do destino indicado). Acrescentar ao tipo de componente do destino os rótulos que o seletor exige, ou cablar o socket a um componente que já os tenha.)
Um anexo cujo componente não satisfaz o campo appliesTo: da Feature. Uma Feature declara a que componentes pode ser anexada, em appliesTo: e em appliesToAnyOf:. Os requisitos da expressão única valem em conjunto e as alternativas valem alternativamente, bastando qualquer uma delas; ambas as superfícies têm de ser satisfeitas, e uma superfície que a Feature omite é satisfeita por qualquer coisa. Um anexo cujo componente traz rótulos que a declaração da Feature não admite é a mesma classe de violação que o caso da aresta acima.
Mensagem emitida:
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. (violação de seletor (a expressão appliesTo indicada, declarada pela Feature indicada, não é satisfeita pelos rótulos do componente indicado). Acrescentar ao tipo deste componente os rótulos que o appliesTo da Feature exige, ou anexar uma Feature cuja aplicabilidade o componente já satisfaça.)
Qualquer uma das expressões pode também ser escrita numa forma que a gramática de rótulos não consegue ler de todo. Isso é comunicado como a mesma interrupção, cujo último valor é o motivo pelo qual não pôde ser lida, e não o conjunto de rótulos que não a satisfez — que é o que distingue uma expressão que não pôde ser avaliada de uma que foi avaliada e resultou falsa:
selector violation ("", declared by Feature "", which could not be evaluated: ""). Correct the appliesTo selector on the Feature’s catalog entity. (violação de seletor (a expressão appliesTo indicada, declarada pela Feature indicada, que não pôde ser avaliada, pelo motivo indicado). Corrigir o seletor appliesTo na entidade de catálogo da Feature.)
Um seletor de socket que a gramática não consegue ler também é recusado antes de qualquer coisa ligar o socket.aggrega validate, sobre todo o catálogo ou sobre um único Component ou uma única Feature, lê todos os seletores de socket que o próprio documento da entidade declara e recusa, sob esta mesma condição, aquele que a gramática não consegue ler, haja ou não alguma aresta ligada através do socket:
selector violation ("", declared on socket "", which could not be evaluated: ""). Correct the selector on the socket’s declaration in the component type’s usesSchema. (violação de seletor, declarado num socket, que não pôde ser avaliado. Corrija o seletor na declaração do socket no usesSchema do tipo de componente.)
Num socket de uma Feature, a correção indica antes o usesSchema da Feature. Nada ligou o socket, pelo que a falha é da entidade de catálogo: é classificada como CATALOG_ERROR e indica o ficheiro da entidade.
A interrupção traz a chave escrita a que diz respeito — a entrada de socket uses:, ou a entrada features: que nomeia o anexo — juntamente com o ficheiro que a declara, pelo que a posição que comunica é a entrada a editar, e não o início do documento. Um Component escrito dentro de um subsistema é posicionado no subsistema sob o qual foi escrito, nível a nível. Um anexo é posicionado na entrada features: que o escreveu, no documento que o escreveu, e atribuído ao autor desse documento: o bloco próprio do componente ou o bloco de um subsistema no Aggregate, um defeito do programador; e, para um anexo que só a Release faz, a sua entrada para o componente ou o bloco features: de uma fronteira que contém o componente, um defeito do operador. Onde ambos os documentos escrevem o anexo, este é posicionado onde o seu type é nomeado, o que o Aggregate faz sempre. Um anexo escrito numa ligação é posicionado na sua chave sob o features: dessa ligação, no documento que o escreveu — a entrada de ligação do Aggregate, ou a entrada por aresta da Release para um anexo que só a Release faz. Uma Feature que apenas a Release anexa a um componente que a sua declaração não admite resulta em:
[OPS_ERROR E0007] release.yaml at .spec.boundaries.main.components.app.features.metrics
selector violation ("component.aggrega.ai/type in (server, worker)", declared by Feature "core/prometheus-exporter", not satisfied by the labels of "app"). Add the labels the Feature's appliesTo requires to this component's type, or attach a Feature whose applicability the component already satisfies.
e o mesmo anexo escrito no componente no Aggregate resulta em [DEVELOPER_ERROR E0007] aggregate.yaml at .spec.components.app.features.metrics. Um anexo produzido pela expansão orientada por anotações não foi escrito por nenhuma entrada features:, pelo que é posicionado na chave features: própria do componente no documento que declara o componente, como defeito do programador.
Como corrigir uma violação de aresta: encaminhar a aresta uses: para um Component cujos rótulos satisfaçam o seletor, ou ajustar a expressão do seletor na entidade do catálogo para aceitar a classe de destino pretendida. Rever os metadata.labels do Component de destino com aggrega inspect para confirmar que rótulos traz.
Como corrigir uma violação de anexo: anexar a Feature a um componente cujos rótulos a sua declaração admite, ou alargar o appliesTo: da Feature — acrescentando uma alternativa sob appliesToAnyOf: onde a Feature serve realmente mais de uma classe de componente. Onde o componente devia qualificar-se e não se qualifica, a peça em falta é normalmente um rótulo: revê-lo com aggrega inspect e acrescentar aquilo que a expressão pede nos metadata.labels do Component.
Unknown provider (Fornecedor desconhecido)
Uma Recipe declara capability: <name> onde <name> não nomeia nenhum fornecedor que o compilador sirva. O compilador não pode encaminhar a renderização para um fornecedor de que nunca ouviu falar.
Mensagem emitida:
unknown provider: <provider-name> (fornecedor desconhecido: o nome indicado)
Como corrigir: confirmar que o nome do fornecedor está escrito corretamente — cloudformation, compose, helm, helm-chart e terraform são os nomes que os plugins fornecedores incorporados servem. Se a intenção era um fornecedor empresarial personalizado, garantir que um Plugin de renderização de fornecedor que sirva esse nome (pluginType: provider com o nome nas suas spec.provider.capabilities) está presente no espaço de trabalho do catálogo para o qual a compilação aponta.
A capability is served by more than one provider plugin (Uma capacidade é servida por mais de um plugin fornecedor)
Uma compilação alcança uma capacidade — ou um pull resolve uma — servida por mais de um Plugin de renderização de fornecedor (pluginType: provider, cada um a listar essa capacidade nas suas spec.provider.capabilities), e o espaço de trabalho não selecionou qual deles a renderiza. Em vez de escolher um fornecedor arbitrariamente, a compilação é interrompida e nomeia ambos os candidatos. Um catálogo que contém dois plugins para a mesma capacidade é válido — dois editores podem cada um distribuir um plugin para helm ou compose, e o catálogo aceita ambos. A ambiguidade só surge no ponto de utilização: a interrupção ocorre quando uma compilação ou um pull alcança efetivamente a capacidade disputada, e não no momento do carregamento.
Mensagem emitida. A regra que interrompeu a compilação vem primeiro, e os pormenores — que capacidade, que candidatos e a associação a escrever — vêm a seguir:
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 (a capacidade é servida por mais de um plugin fornecedor; acrescentar uma entrada plugins.providers para selecionar um: a capacidade indicada é servida por mais de um plugin fornecedor (os indicados); acrescentar uma entrada plugins.providers para a capacidade indicada que selecione um)
Como corrigir: acrescentar uma entrada plugins.providers na configuração do espaço de trabalho, com a capacidade como chave e cujo valor seleciona a identidade do plugin que a renderiza. Manter ambos os plugins no catálogo federado; a associação indica a este espaço de trabalho para qual deles encaminhar a capacidade disputada.
The plugin serving a provider cannot assemble what that provider combines (O plugin que serve um fornecedor não consegue montar aquilo que esse fornecedor combina)
Um fornecedor declara o que acontece à saída por nó de um grupo de encaminhamento: a saída de cada nó escrita diretamente no caminho de encaminhamento, os fragmentos combinados num único documento, ou cada nó colocado numa posição própria dentro de uma única estrutura que os envolve. Onde um fornecedor declara que a saída é combinada — um ficheiro compose fundido, um chart guarda-chuva — o plugin que o serve tem de oferecer o export que faz a combinação. Esta interrupção ocorre onde não o faz: o plugin anuncia a renderização por nó (render_node) e nenhum assemble_boundary correspondente, pelo que os nós do grupo podem ser renderizados, mas a sua saída não pode ser fundida.
As duas metades dessa divergência pertencem ao plugin. O que acontece à saída de um grupo de encaminhamento faz parte daquilo que o plugin comunica sobre si próprio quando é carregado, e o export que faria a combinação é uma das entradas sob spec.exports de uma entidade Plugin, confrontada com essa mesma comunicação — pelo que a interrupção nomeia um plugin que declara uma montagem que a sua superfície de export não fornece.
A compilação é interrompida em vez de saltar a montagem. Saltá-la escreveria o fragmento de cada nó no caminho em que se esperava um único artefacto e comunicaria sucesso, e nada mais adiante consegue distinguir esses fragmentos da saída plana por nó que um fornecedor que não declara nenhuma montagem emite por conceção — pelo que um artefacto em falta surgiria onde quer que a saída fosse aplicada, e não no momento da compilação.
Um grupo de encaminhamento sem caminho de encaminhamento é ignorado. A saída escrita em nenhum caminho é saída por nó, pelo que nada é aí montado sobre o qual uma declaração de combinação possa incidir.
Mensagem emitida — uma constatação por cada grupo de encaminhamento infrator, que nomeia o fornecedor e o caminho em que esse grupo se monta:
provider expected to assemble its dispatch group provides no boundary assembler ("<provider>", dispatch path "<path>") (o fornecedor que devia montar o seu grupo de encaminhamento não fornece nenhum montador de fronteira (com o fornecedor e o caminho de encaminhamento indicados))
Onde mais de um grupo de encaminhamento é infrator, as constatações chegam em conjunto sob a comunicação dispatch groups whose provider offers no boundary assembler.
Como corrigir: servir a capacidade com um plugin que anuncie tanto render_node como assemble_boundary — consultar ../entities/plugin.md para a superfície de autoria spec.exports, e ../schema/plugins/wasm-provider.md para aquilo que o export de montagem recebe. Quando o plugin é da sua autoria, cabe-lhe alinhar os dois lados: acrescentar o export de montagem, ou não comunicar nenhuma declaração de montagem e deixar a saída de cada nó chegar ao caminho de encaminhamento sem ser fundida. Quando se consome um plugin publicado, selecionar uma versão que ofereça ambos os exports, ou selecionar um plugin cujo fornecedor não declare nenhuma montagem para essa capacidade.
A boundary-level Feature’s output reaches no assembled file (A saída de uma Feature de âmbito de fronteira não chega a nenhum ficheiro montado)
Uma Feature anexada sob o features: de uma fronteira, cuja FeatureRecipe declara executionScope: boundary, é renderizada uma única vez para toda a fronteira, e a sua saída vai para o diretório para o qual o directory: e o subDirectory: próprios da fronteira são avaliados para ela. Um fornecedor que combina a sua saída num único documento — compose, num único docker-compose.yaml; cloudformation, numa única stack — escreve o contributo de uma Feature dessas apenas como parte do ficheiro que aí monta a partir dos componentes da fronteira. Esse ficheiro só existe onde a saída de pelo menos um componente chega ao mesmo diretório sob o mesmo fornecedor.
Não existe onde os componentes da fronteira chegam a outro lado: quando se encontram em fronteiras aninhadas cujo subDirectory: os envia para outro lado — "{{ .component_id }}", por exemplo, para que cada componente tenha um ficheiro próprio — ou sob um diretório que a saída da Feature não partilha. Nada é montado no diretório da Feature, pelo que a sua saída não seria escrita em lado nenhum — para a ponte compose, um serviço de gateway que nenhum ficheiro contém — e a compilação comunicaria sucesso. Em vez disso, a compilação é interrompida.
Uma Feature cujo fornecedor escreve cada contributo como ficheiros próprios — helm, helm-chart e terraform — não é afetada: esses ficheiros são escritos quer algo seja montado ao lado deles, quer não.
Mensagem emitida — uma constatação por cada Feature infratora, posicionada na sua entrada sob o features: da fronteira, que nomeia a fronteira, a Feature, o caminho de encaminhamento para o qual a sua saída foi dirigida e o fornecedor:
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 (a saída da Feature de âmbito de fronteira é dirigida para um caminho de encaminhamento em que nada é montado (com a fronteira, a instância de Feature, o caminho de encaminhamento e o fornecedor indicados). anexar a Feature a uma fronteira cujo caminho de saída também receba os seus componentes, ou dar aos componentes da fronteira o diretório para o qual a saída da Feature é dirigida)
Uma ponte compose anexada a uma fronteira mãe bridge, cuja única fronteira filha coloca cada componente sob subDirectory: "{{ .component_id }}", apresenta:
[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
Onde mais de uma Feature é infratora, as constatações chegam em conjunto sob a comunicação boundary-level Features whose output is routed to a dispatch path nothing assembles.
Como corrigir: fazer com que o diretório da Feature seja um diretório onde também chegam os componentes da sua fronteira. Anexar a Feature a uma fronteira cujo próprio caminho de saída receba esses componentes, ou dar aos componentes o diretório para o qual a saída da Feature é dirigida — para fronteiras filhas, directory: "{{ .parent_boundary.directory }}" sem um subDirectory: próprio, para que partilhem o ficheiro da fronteira mãe. A mensagem nomeia o diretório para o qual a saída da Feature foi dirigida, que é o que deve ser partilhado.
Path-template references a variable outside the allowlist (O template de caminho referencia uma variável fora da lista de permissões)
Um template directory: ou subDirectory: referencia um nome de variável que a lista de permissões de variáveis de templates de caminho não inclui — por exemplo, um erro ortográfico como {{ .parmaeters.region }}, ou um campo que existe no contexto de renderização da Recipe, mas não é exposto aos templates de caminho (como .context.inject ou .values). A mesma interrupção abrange {{ .component_id }} num template directory:: a variável existe, e os templates subDirectory: podem lê-la, mas o directory: de uma fronteira é avaliado uma única vez para toda a fronteira, e não uma vez por componente, pelo que aí uma variável por componente faria o caminho emitido depender do componente que por acaso fosse avaliado primeiro.
Os templates de caminho são validados no momento da análise, antes de começar qualquer trabalho de renderização, em relação às variáveis que o contexto de templates de caminho define, menos as que a superfície em causa recusa. O compilador avalia também os templates de caminho com a semântica missingkey=error, pelo que uma referência que consta da lista de permissões, mas não está definida no momento da avaliação, produz um erro explícito em vez de renderizar silenciosamente uma cadeia vazia num caminho de diretório.
Esta interrupção diz respeito à variável. Uma chave mal escrita sob uma variável permitida — {{ .manifest.recipe_nmae }} — comunica em vez disso «Template references a root the render context does not define (O template referencia uma raiz que o contexto de renderização não define)» mais acima, nomeando as chaves que .manifest define, porque a própria variável foi admitida e só a chave estava errada.
Mensagem emitida:
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>") (o template de caminho referencia um campo que não consta da lista de permissões documentada (com o caminho indicado, escrito no campo indicado; o contexto de renderização define as variáveis indicadas))
Como corrigir: corrigir o nome do campo para um que conste da lista de permissões dos templates de caminho, ou remover a referência. A lista de permissões para directory: é {{ .capability }}, {{ .boundary_name }}, {{ .parameters.X }}, {{ .manifest.recipe_name }} e {{ .parent_boundary.* }}; subDirectory: acrescenta {{ .component_id }}. Outras superfícies (valuesMapping da Recipe, injectMapping da FeatureRecipe, etc.) usam uma forma de contexto diferente; as referências a .context.*, .values, .infra ou .locals não são deliberadamente expostas aos templates de caminho, porque a emissão de caminhos é uma questão estrutural, e não uma questão de renderização de valores.
Path collision: two contributors emit at incompatible paths (Colisão de caminhos: dois contribuidores emitem em caminhos incompatíveis)
Duas fronteiras cujas declarações de caminho são avaliadas para o mesmo caminho de montagem passam por fornecedores diferentes. Ambos montam aí, e cada um escreve ficheiros de que o outro nada sabe, pelo que um substitui silenciosamente o outro no disco — e a compilação que produziu a saída substituída parece ter sido bem-sucedida.
O subDirectory: predefinido dá a cada fornecedor um subcaminho próprio, pelo que dois fornecedores só chegam a um mesmo caminho onde as declarações foram escritas para serem avaliadas da mesma forma: duas fronteiras que partilham um directory: e que fixam ambas subDirectory: no mesmo literal, por exemplo.
Mensagens emitidas. É comunicada uma constatação por cada fronteira contribuidora, pelo que cada fronteira cuja saída chegou ao caminho é nomeada individualmente, em vez de agrupada numa lista dentro de uma única mensagem. A falha consiste em dois fornecedores se encontrarem num mesmo caminho, pelo que há sempre pelo menos duas constatações, e estas chegam em conjunto sob uma comunicação que indica o que têm em comum:
assembly paths reached by more than one provider (caminhos de montagem alcançados por mais de um fornecedor)
Cada constatação nomeia o caminho, a fronteira cuja saída chegou a ele e o fornecedor pelo qual essa fronteira passa:
dispatch path produced multiple provider outputs ("<path>", boundary "<boundary>", provider "<provider>") (o caminho de encaminhamento produziu várias saídas de fornecedor (com o caminho, a fronteira e o fornecedor indicados))
Uma compilação cujas fronteiras api-net e db-net declaram ambas directory: ./dist/shared e subDirectory: merged, uma dirigida através de helm e a outra através de compose, apresenta:
A comunicação traz o código curto e cada constatação abaixo dela traz apenas a sua categoria, que é a forma que toda a comunicação de falhas recolhidas usa — consultar error-translation.md para essa gramática.
Como corrigir: dar a cada fronteira um directory: distinto (para que se montem em caminhos separados), ou deixar subDirectory: no seu valor predefinido para que a saída de cada fornecedor chegue a um subcaminho próprio. O esquema da ponte compose reúne intencionalmente duas subfronteiras num único caminho de montagem; esse esquema exige que ambas as fronteiras tenham como alvo o mesmo fornecedor e tragam anotações resolvidas em cascata compatíveis.
A boundary’s output directory is not a directory beneath the output root (O diretório de saída de uma fronteira não é um diretório sob a raiz de saída)
O directory: e o subDirectory: de uma fronteira são avaliados e unidos no diretório sob o qual a sua saída é escrita, e esse caminho é normalizado uma vez: out/a, out//a, ./out/a e out/a/ são um único diretório. Onde o caminho normalizado não é um diretório sob a raiz de saída, a compilação para antes de qualquer coisa ser escrita. Trata-se de um caminho que sobe para fora da raiz de saída (.., ../escape, a/../..), de um caminho absoluto (/srv/out), ou de um que não nomeia diretório nenhum: um valor vazio, ou um que se normaliza na própria raiz de saída, como directory: "." com o subdiretório desativado.
O caminho é verificado tal como foi avaliado, pelo que é o resultado de um template que é julgado, e não o texto escrito. A mensagem nomeia o campo de onde vem a falha — directory: onde o diretório sozinho já sai da raiz de saída ou onde nenhum subdiretório lhe é unido, e subDirectory: nos restantes casos — juntamente com o valor para o qual esse campo foi avaliado e o caminho que produziu.
Mensagem emitida:
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 (o diretório de saída da fronteira não nomeia um diretório sob a raiz de saída (com a Release, a fronteira, o valor de directory e o caminho de saída indicados). escrever um diretório sob a raiz de saída, como «deploy/prod» — sem «/» inicial, sem «..» a subir acima dela, e não a própria raiz de saída)
Onde a falha está no subdiretório, o terceiro valor indica em vez disso subDirectory: "<value>".
Como corrigir: escrever o campo que a mensagem nomeia como um diretório sob a raiz de saída. Um diretório que se pretende ao lado da raiz de saída deve, em vez disso, ficar dentro dela. Para escrever a saída de uma fronteira diretamente no seu directory:, definir subDirectory: "." — o próprio diretório tem ainda de nomear um diretório próprio.
A boundary-level Feature is named . or .. (Uma Feature de âmbito de fronteira chama-se . ou ..)
Um fornecedor que dá a cada contribuidor um diretório próprio — terraform, sob modules/, e helm-chart, sob charts/ — coloca uma Feature anexada a uma fronteira num diretório com o nome apenas da instância, ao lado dos componentes da fronteira. A chave features: de uma fronteira admite . e .., e nenhum deles é um nome de diretório: . colocaria os ficheiros da Feature no diretório que contém todos os contribuidores, e .. no diretório acima dele, pelo que os ficheiros ficariam fora da posição que o fornecedor deu à Feature. Em vez disso, a compilação para. Qualquer outro nome não é alterado, incluindo um com pontos como audit.v2.
Mensagem emitida:
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” (o nome de instância da Feature de âmbito de fronteira não é um nome de diretório (com a Release, a fronteira e a instância de Feature indicadas). mudar o nome da instância de Feature sob os features da fronteira para um nome comum, como «audit»)
Como corrigir: mudar o nome da instância sob o features: da fronteira para um nome comum.
Instance-ID collision across boundaries assembling to the same path (Colisão de ID de instância entre fronteiras que se montam no mesmo caminho)
Duas fronteiras que se montam no mesmo tuplo (caminho, fornecedor) contribuem com componentes com IDs de instância idênticos. A montagem fundida não consegue distinguir os dois fragmentos de componente — um único chart Helm não pode conter dois Deployments chamados web-server, e um único ficheiro docker-compose não pode conter dois serviços chamados api.
Mensagem emitida:
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 (vários contribuidores partilham um ID de instância no mesmo caminho de encaminhamento: o caminho de encaminhamento e o fornecedor indicados já contêm o nó indicado (com as fronteiras contribuidoras indicadas); os IDs de instância dos componentes têm de ser únicos dentro de um grupo de montagem)
Como corrigir: mudar o nome de um dos componentes em colisão no Aggregate, ou separar as duas fronteiras em caminhos directory: distintos para que cada instância de componente chegue à sua própria montagem.
Two contributors write the same output path (Dois contribuidores escrevem o mesmo caminho de saída)
Dois contribuidores de uma mesma montagem produzem um ficheiro no mesmo caminho de saída. Isto é distinto da colisão de ID de instância acima: os componentes têm nomes diferentes e a montagem consegue distingui-los — são os ficheiros que emitem que acabam num mesmo caminho. Acontece com mais frequência onde um fornecedor escreve a saída de cada contribuidor lado a lado em vez de sob uma posição por componente, pelo que dois componentes cujas Recipes emitem o mesmo nome de ficheiro (duas entradas artifacts: ambas chamadas main.tf, por exemplo) se encontram num mesmo caminho. A saída própria do montador pode colidir com o ficheiro de um contribuidor da mesma forma.
Se dois contribuidores que emitem um mesmo nome de ficheiro colidem depende de onde o seu fornecedor os coloca. Um fornecedor que aninha cada contribuidor sob a sua própria posição na montagem mantém separados dois ficheiros com o mesmo nome; um fornecedor que escreve os contribuidores lado a lado não o faz. A comparação incide sobre o caminho final em que um ficheiro seria escrito, e não sobre o nome que o contribuidor emitiu, pelo que o caso aninhado não é comunicado.
A compilação é interrompida em vez de escrever um dos dois ficheiros e descartar o outro. Não existe nenhuma resolução silenciosa correta: mudar o nome de um ficheiro ou acrescentar-lhe um sufixo inventaria um nome que ninguém escreveu, e fundir os seus conteúdos inventaria um documento que ninguém redigiu. Todos os caminhos em colisão são comunicados, e todos os contribuidores que os escrevem são nomeados, pelo que uma única compilação mostra o quadro completo em vez de uma colisão de cada vez.
Mensagens emitidas. É comunicada uma constatação por caminho em colisão — uma única vez, independentemente de quantas fronteiras tenham alimentado a montagem em que ocorreu —, pelo que uma compilação cujos contribuidores se encontraram em dois caminhos informa sobre ambos e nenhuma colisão é comunicada duas vezes:
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>") (colisão na saída montada: dois contribuidores escrevem o mesmo caminho de saída (com o caminho de saída, os contribuidores que o escrevem e as fronteiras dentro das quais foi montado indicados))
Cada contribuidor é nomeado por aquilo que é, o que indica onde o seu nome está escrito: component <name> para uma instância de componente, feature <name> para uma funcionalidade anexada a uma fronteira, e the <provider> assembly para a saída fundida própria da montagem. Os contribuidores são listados por ordem de nome, pelo que a frase é a mesma em todas as compilações da mesma entrada.
Um ficheiro com que uma Recipe contribui para a saída partilhada da fronteira também está sujeito a esta regra. O bloco boundary: de uma Recipe escreve os seus ficheiros ao lado da saída montada própria do fornecedor, uma vez por nome de ficheiro. Vários componentes que declaram um nome com bytes idênticos são um único ficheiro e nunca colidem; declará-lo com bytes diferentes colide aqui, nomeando o ficheiro e cada componente que o declarou, e o mesmo acontece com um nome que a própria montagem do fornecedor escreve — aggrega.modules.tf para terraform, por exemplo, que nomeia the terraform assembly entre os contribuidores. Um ficheiro que vários componentes declararam de forma idêntica e que encontra o ficheiro próprio da montagem é nomeado com todos eles, como component <name-1> and component <name-2>.
As fronteiras que alimentaram a montagem também são nomeadas, e são listadas em vez de destacadas individualmente. Fronteiras cujas declarações directory: são avaliadas da mesma forma são montadas como uma só, e nada numa colisão diz em qual delas foram declarados os contribuidores que se encontraram — pelo que a constatação indica todas as fronteiras cuja declaração os poderia separar e não afirma de nenhuma que seja aquela em que está o defeito. A constatação é comunicada sobre o documento da Release no seu todo pela mesma razão: nomear uma fronteira dentro dele remeteria para um documento que pode não ter contribuído com nada para o caminho.
Onde colide mais de um caminho, as constatações chegam juntas sob uma comunicação que indica aquilo que têm em comum:
assembled output paths written by more than one contributor (caminhos da saída montada escritos por mais de um contribuidor)
Como corrigir: mudar o nome do ficheiro emitido na Recipe que se controla — uma chave de artifacts:, a chave de um bloco boundary:, ou o nome de ficheiro que uma tradução de Workload deriva — para que os dois deixem de se encontrar. Onde duas Recipes declaram um mesmo ficheiro partilhado e pretendem a mesma configuração, tornar as suas declarações idênticas byte a byte. Onde os dois contribuidores pertencem realmente a saídas separadas, atribuir às suas fronteiras caminhos directory: distintos para que cada uma seja montada por si.
The same name is derived more than once inside the output (O mesmo nome é derivado mais de uma vez dentro da saída)
Uma montagem acaba por usar o mesmo nome duas vezes para algo dentro dos ficheiros que emite, num ponto onde só há lugar para um. Acontece de duas formas: dois contribuidores derivam o mesmo nome, ou a saída própria de um único contribuidor traz esse nome duas vezes. Isto é distinto das duas colisões acima: onde estão envolvidos dois contribuidores, os componentes têm nomes diferentes e os seus ficheiros acabam em caminhos diferentes, pelo que nada na estrutura da montagem está errado — é um nome no conteúdo, como o identificador que um destino usa para endereçar um recurso, ou o nome sob o qual uma saída é publicada para que outra a referencie.
Os nomes que são comparados decorrem daquilo que o fornecedor faz com a saída de uma montagem. Onde o fornecedor funde essa saída num único documento — um template de stack, um ficheiro compose —, os nomes dentro desse documento são comparados entre si, e um contribuidor cuja saída é escrita como ficheiros separados próprios fica fora dele. Os seus nomes não encontram os de mais ninguém, pelo que nada é interrompido entre eles, e nada que se pudesse renomear mudaria isso. Onde, em vez disso, o fornecedor escreve a saída de cada contribuidor como ficheiros próprios — uma renderização de chart, um conjunto de manifestos —, cada contribuidor da montagem é comparado com todos os outros, porque um nome numa saída desse tipo é único em tudo aquilo que lê esses ficheiros como um conjunto, e não dentro de um único ficheiro.
Os recursos próprios de uma FeatureRecipe seguem o mesmo caminho que os do seu componente anfitrião, porque um anexo contribui para a montagem a que o seu anfitrião pertence. Assim, onde o fornecedor funde, os nomes de um anexo são comparados com os do seu componente anfitrião e com os de todos os outros anexos, exatamente como os nomes de dois componentes: todos acabam dentro do único documento, e de dois nomes iguais um substitui o outro aí. Onde o fornecedor não funde, os recursos do anexo são escritos sob um diretório que nomeia o componente a que está anexado, e os seus nomes continuam a ser comparados com cada contribuidor da montagem — que é onde é detetada uma identidade de recurso que tem de ser única em todo um cluster. A comparação é, portanto, a mesma em ambos os casos, e o que difere é apenas onde acaba por ficar o nome que seria substituído.
Uma metade da interrupção não é afetada por nada disto: a saída própria de um único contribuidor a trazer um nome duas vezes. Trata-se de um nome usado duas vezes numa saída que um único contribuidor escreveu, pelo que provoca uma interrupção onde quer que essa saída tenha sido escrita, e as duas coisas a separar estão sempre dentro dela.
A maioria desses nomes pertence a um fornecedor, derivados da instância de componente e do recurso, pelo que dois componentes podem chegar a um mesmo nome sempre que as partes de que é derivado coincidam — e um componente pode chegar duas vezes a um mesmo nome da mesma forma, quando dois dos seus próprios recursos são construídos a partir de partes que coincidem. Como o nome vive nos próprios bytes do ficheiro, a montagem não o consegue ver: o fornecedor comunica os nomes que derivou, e a compilação compara-os.
Um tipo de nome pertence à compilação e não a um fornecedor, e é comunicado da mesma forma: a identidade com que é rotulado cada recurso que uma FeatureRecipe emite, que chega à saída como o rótulo aggrega.ai/component-id. É comunicada sob o tipo de nome component-id, para que seja possível encontrar a mesma string na saída emitida. Onde uma FeatureRecipe sintetiza os seus recursos, essa identidade é também aquilo a partir do qual são nomeados; onde renderiza um chart ou um fragmento fornecido pelo seu autor, os nomes dentro dessa renderização continuam a ser os do componente anfitrião e apenas os rótulos trazem a identidade.
Para uma funcionalidade anexada a um componente, é composta a partir do componente a que a funcionalidade está anexada e da chave escrita sob features:, após um prefixo fixo. O componente anfitrião faz parte do valor porque um mesmo nome de funcionalidade anexado a vários componentes emite um conjunto separado de recursos em cada um, e cada conjunto precisa de uma identidade própria.
Para uma funcionalidade anexada a uma fronteira, é composta a partir do nome da funcionalidade e de cada segmento do caminho da fronteira, após um prefixo próprio. Ambos os casos compõem em vez de substituir: um carácter que o alfabeto de rótulos recusa é transcrito em vez de substituído, e as partes são unidas por uma sequência que nenhuma parte escrita pode conter, pelo que dois anexos que se conseguem distinguir chegam sempre a duas identidades. O único resíduo é o comprimento: uma identidade composta demasiado longa para o valor de um rótulo é encurtada em torno de um digest da sua totalidade, e duas identidades encurtadas podem, em princípio, encontrar-se. Esta interrupção comunica um encontro desse tipo entre dois contribuidores cujos nomes são comparados, e dois anexos num componente são dois contribuidores desse tipo onde quer que o fornecedor do seu anfitrião os monte em conjunto. Ver ../providers/well-known-annotations.md para saber como cada uma é construída.
Uma renderização do Kubernetes comunica um tipo de nome próprio: o nome que cada recurso produzido pela sua própria renderização traz no seu metadata.name. Um nome desse tipo tem de ser único dentro do seu kind — e, para um tipo que o cluster mantém em namespaces, dentro do seu namespace — e não em toda a saída, pelo que o tipo de nome diz a qual desses âmbitos se restringe. Começa por resource-names e depois traz o kind do recurso e o namespace em que o recurso fica, que é aquele que o recurso nomeia para si próprio ou, onde não nomeia nenhum, aquele com que a fronteira está anotada. Assim, resource-names:Service--default são os nomes dos Services que ficam em default. Um tipo que a API do Kubernetes mantém fora de qualquer namespace — um ClusterRole, uma StorageClass, uma CustomResourceDefinition — e um tipo personalizado que uma CustomResourceDefinition na mesma renderização declara com o âmbito Cluster trazem apenas o seu kind, seja qual for o namespace que o seu documento escreva: resource-names:ClusterRole são os nomes de todos os ClusterRole que a saída traz. Tudo o que fica fora das letras e dos dígitos é transcrito em vez de substituído e as duas partes são unidas por uma sequência que nenhuma parte escrita pode conter, pelo que dois pares diferentes nunca chegam a um mesmo tipo de nome, e um tipo sozinho nunca chega ao tipo de nome de um tipo e de um namespace. Um Service e um Deployment podem partilhar um nome, e dois namespaces contêm um mesmo nome de um tipo com namespace de forma independente, pelo que nenhum desses casos provoca uma interrupção. O próprio nome é comunicado exatamente como o chart o escreveu, o que faz dele a string a procurar nos templates.
Assim, dois contribuidores de uma mesma saída que escrevem cada um um mesmo objeto ao nível do cluster sob um mesmo nome provocam uma interrupção mesmo onde a Release os coloca em dois namespaces, porque aplicar ambos escreve esse único objeto duas vezes; e um chart que escreve um objeto desse tipo sob dois namespaces diferentes, que a renderização emite como dois ficheiros, provoca uma interrupção como um único contribuidor que traz o nome duas vezes. Um tipo que nada na renderização classifica — um tipo personalizado cuja CustomResourceDefinition a renderização não emite, ou um documento que não nomeia nenhum apiVersion — é comparado dentro do seu namespace, como um tipo com namespace, porque nada na renderização diz que o cluster o mantém fora de um; dois contribuidores que escrevem um objeto desse tipo em dois namespaces não se encontram, portanto.
Os nomes são comparados entre os contribuidores de uma mesma saída, e nunca entre duas saídas. Duas fronteiras são duas saídas quando cada uma tem um diretório próprio — um que nomeia, ou aquele que é atribuído a cada fronteira que não nomeia nenhum directory: — e nada numa compilação diz se duas saídas são aplicadas a um mesmo cluster ou a dois: a CustomResourceDefinition de um mesmo operador enviada para cada um de dois clusters é o mesmo nome em duas saídas, e isso está correto. Assim, duas fronteiras que escrevem cada uma um mesmo objeto ao nível do cluster sob um mesmo nome não interrompem a compilação mesmo onde ambas são aplicadas a um mesmo cluster; onde o forem, emitir o objeto a partir de apenas uma delas.
A disposição que chega a esta interrupção com mais frequência é a de duas Features anexadas a um mesmo componente, cada uma a entregar um chart fornecido pelo seu autor. Ambos os charts são renderizados com o mesmo nome de release — o do componente anfitrião, para que anexar um chart não mude o nome de recursos que o seu autor já declarou e implementou — e nomear um recurso a partir do nome de release está entre as coisas mais comuns que um chart faz. Nada na estrutura da saída está errado: os dois recursos trazem simplesmente um mesmo nome. Onde o fornecedor do componente escreve documentos separados, cada anexo escreve sob um diretório próprio e aplicar ambos deixa aquele que foi aplicado em último lugar; onde junta o seu grupo num único documento, ambos os anexos contribuem para esse documento e um dos dois nomes substitui o outro dentro dele. Mudar o nome do recurso no chart que se controla, ou dar-lhe um nome que traga algo que distinga os dois anexos — e é o anexo que tem de chegar ao template, porque ambos os charts são renderizados com o nome de release do anfitrião, pelo que mudar apenas o nome do anexo não altera nada. Passar .attachment_name para o chart através do valuesMapping: da FeatureRecipe, e defini-lo naquele dos valores próprios do chart a partir do qual os nomes dos seus recursos são construídos.
Uma segunda disposição chega à mesma interrupção com uma única Feature em vez de duas: um chart cujo template escreve um nome de recurso como literal, anexado a dois componentes. Cada anfitrião renderiza-o com um nome de release próprio, pelo que o literal é a única razão pela qual as duas cópias trazem um mesmo nome — nomear o recurso a partir de .Release.Name faz com que o anfitrião volte a fazer parte dele, que é o que um chart que constrói os nomes dos seus recursos a partir da sua identidade de release já faz.
Uma terceira disposição tem a mesma estrutura, uma superfície de autoria mais para dentro: uma FeatureRecipe que entrega os seus recursos através de artifacts: em vez de através de um chart, anexada sob um mesmo nome a dois componentes, cujo corpo escreve um nome de recurso como literal. A saída de cada anexo fica sob um diretório que nomeia o seu anfitrião, pelo que os caminhos emitidos diferem e nada na estrutura da saída está errado — mas ambos os corpos trazem o mesmo nome, e aplicar ambos deixa aquele que foi aplicado em último lugar. Um nome num corpo de artifacts é comparado exatamente como um nome que um chart renderizou: os dois descrevem o mesmo recurso no mesmo cluster, pelo que a origem do nome não faz diferença para aquilo que acontece quando ambos são aplicados. Essa leitura assenta em os dois nomes serem lidos em conjunto, o que acontece onde um fornecedor escreve a saída de cada contribuidor como ficheiros que um destino lê como um único conjunto. Onde, em vez disso, o fornecedor funde a saída de uma montagem num único documento, os ficheiros de cada anexo ficam fora desse documento e um nome dentro de um deles restringe-se a esse ficheiro, pelo que dois anexos desse tipo nunca se encontram e a compilação prossegue.
Nem todos os nomes são comunicados, pelo que uma compilação que não é interrompida não estabeleceu que todos os nomes que a sua saída acabará por trazer foram comparados. Um recurso cujo nome fica a cargo do cluster — um que declara generateName em vez de name — ainda não traz nenhum nome, pelo que não há nenhum a comunicar. E um nome escrito noutro campo para que um controlador o leia mais tarde não é um nome de recurso, pelo que nada o compara. Ambos os limites são propriedades da leitura do documento emitido, pelo que ambos se aplicam a um corpo de artifacts exatamente como se aplicam a um template de chart renderizado.
Um corpo de artifacts: é um template, pelo que um nome dentro dele que tem de ser distinto em cada anfitrião é composto em vez de escrito como literal. .context.rendered_name é o nome que o próprio fornecedor do componente anfitrião lhe atribui — com helm, o seu nome de release, escrito nos caracteres que um nome do Kubernetes admite — e .attachment_name é a chave sob a qual foi anexado, pelo que {{ .context.rendered_name }}-{{ .attachment_name }} dá a um recurso um nome próprio em cada anfitrião e sob cada anexo. Num anfitrião cujo fornecedor não comunica nenhum nome desse tipo, compô-lo, em vez disso, a partir de .context.instance_id, a identidade do anfitrião. Um mesmo corpo escrito chega a cada anfitrião a que está anexado trazendo os nomes que contiver, e um literal é o mesmo em todos eles — pelo que um nome que tenha de ser único no cluster deve ter essa estrutura.
Nada do significado de um nome é interpretado — dois nomes comunicados ou são o mesmo texto ou não são —, e é por isso que a mesma comunicação abrange todos os tipos de nome, seja quem for que o tenha derivado.
Um nome pode aparecer em mais de uma comunicação para um mesmo componente, porque cada parte de um componente é comunicada à medida que é renderizada. Trata-se de um único recurso nomeado em cada comunicação a que pertence, e não de um nome usado duas vezes, e não provoca uma interrupção. O que provoca uma interrupção é uma única comunicação que traz um nome duas vezes, porque essa comunicação descreve uma saída em que o nome é realmente usado duas vezes.
Essa leitura depende daquilo que conta como um único contribuidor, e para o tipo component-id a resposta é o anexo, e não o componente ou a fronteira em que se encontra. Um anexo é identificado pelas duas coordenadas escritas para ele — o componente a que está anexado juntamente com a chave sob features:, ou o caminho da fronteira juntamente com o nome nessa fronteira —, pelo que dois anexos num só componente são dois contribuidores, exatamente como o são dois em componentes diferentes, e um nome de funcionalidade escrito em duas fronteiras são dois contribuidores, ainda que o nome seja o mesmo em cada uma. Ser dois contribuidores é o que torna as suas identidades comparáveis em cada uma dessas disposições; se dois deles chegam sequer a ser comparados segue a mesma regra que qualquer outro nome aqui, pelo que, onde o fornecedor funde, um anexo cuja saída é escrita como ficheiros separados próprios fica fora do documento fundido e só é comparado consigo próprio. Dois anexos que chegam a uma mesma identidade provocam, portanto, uma interrupção onde quer que a saída de um possa alcançar a do outro, e cada constatação nomeia as suas duas coordenadas para que seja possível saber quais as duas coisas a separar. Como ambas as coordenadas fazem parte do valor composto, dois anexos que se conseguem distinguir chegam a duas identidades em qualquer comprimento que caiba — pelo que a disposição que chega a esta interrupção é aquela em que um valor demasiado longo para o seu destino foi encurtado e dois valores encurtados se encontraram. Onde duas identidades encurtadas se encontram e a saída de um não pode alcançar a do outro — dois anexos num componente, sob um fornecedor que funde, cada um escrito como ficheiros separados próprios —, nada os compara, e os dois conjuntos de recursos trazem entre si um mesmo aggrega.ai/component-id.
Há uma disposição que merece ser enunciada explicitamente, porque parece que deveria provocar uma interrupção e não provoca: anexar uma funcionalidade sob o mesmo nome a dois componentes é totalmente suportado e não exige nenhuma mudança de nome. O componente faz parte do valor composto, pelo que metrics em api e metrics em web chegam a duas identidades e os recursos de cada componente recebem uma identidade própria — o que importa porque uma cascata que, intencionalmente, atribui um mesmo nome de anexo a muitos componentes não deixa ao autor nenhum outro nome para escrever. Todas as formas pelas quais uma FeatureRecipe entrega recursos colocam a sua identidade naquilo que emite, incluindo aquela que apenas incorpora uma fonte e a renderiza tal como está, pelo que todas são comparadas; uma funcionalidade cuja FeatureRecipe não emite absolutamente nada não tem nada a comparar.
A compilação é interrompida em vez de manter um e descartar o outro. Não existe nenhuma resolução silenciosa correta: manter o primeiro retiraria por completo da saída um recurso declarado e deixaria a compilação a comunicar sucesso, e tudo o que referenciasse o recurso retirado passaria discretamente a resolver-se para o que restou. Todos os nomes em colisão são comunicados, cada um com o tipo de nome que é e com todos os contribuidores que o derivaram nomeados — pelo que uma única compilação mostra o quadro completo em vez de uma colisão de cada vez. Um contribuidor cuja saída própria traz o nome duas vezes é nomeado como tendo derivado o nome mais de uma vez, e é isso que indica que as duas coisas a separar estão dentro desse único componente, e não entre dois deles.
Mensagens emitidas. É comunicada uma constatação por contribuidor e por nome em colisão, pelo que cada contribuidor que derivou o nome é nomeado individualmente, em vez de agrupado numa lista dentro de uma única mensagem. Onde dois contribuidores derivaram o nome há pelo menos duas constatações, e chegam juntas sob uma comunicação que indica aquilo que têm em comum:
dispatch groups whose contributors derive one name more than once in one key space (grupos de encaminhamento cujos contribuidores derivam um mesmo nome mais de uma vez num mesmo espaço de chaves)
Cada constatação nomeia o nome, o tipo de nome que é, o contribuidor que o derivou, e o fornecedor e o caminho da montagem em que a sua saída é fundida:
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>") (colisão de nomes derivados: um mesmo nome é derivado mais de uma vez num mesmo espaço de chaves (com o nome, o espaço de chaves, o componente que o derivou, o fornecedor e o caminho de encaminhamento indicados))
O contribuidor é nomeado por aquilo que é, o que indica onde o seu nome está escrito: derived by component para uma instância de componente, e derived by feature para uma funcionalidade anexada a uma fronteira.
Onde o próprio nome do contribuidor não o identifica por si só, segue-se uma segunda coordenada, e qual é depende do tipo. Uma funcionalidade anexada a uma fronteira traz o caminho da fronteira, porque um mesmo nome de funcionalidade pode estar escrito em mais de uma fronteira:
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>") (colisão de nomes derivados: um mesmo nome é derivado mais de uma vez num mesmo espaço de chaves (com o nome, o espaço de chaves, a funcionalidade que o derivou, a fronteira a que está anexada, o fornecedor e o caminho de encaminhamento indicados))
Um componente traz a chave do anexo cuja renderização derivou o nome, porque um componente traz um anexo por cada chave escrita:
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>") (colisão de nomes derivados: um mesmo nome é derivado mais de uma vez num mesmo espaço de chaves (com o nome, o espaço de chaves, o componente que o derivou, o anexo que traz, o fornecedor e o caminho de encaminhamento indicados))
A renderização própria de um componente — um nome que o seu fornecedor derivou para o próprio componente, e não para um dos seus anexos — não traz nenhuma segunda coordenada, pelo que a constatação termina no nome do componente.
Onde a saída própria de um único contribuidor traz o nome duas vezes, esse contribuidor é a única constatação, pelo que chega sozinho, sem nenhuma comunicação acima dele — e é nomeado como tendo derivado o nome mais de uma vez, e não como tendo encontrado outro 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>") (colisão de nomes derivados: um mesmo nome é derivado mais de uma vez num mesmo espaço de chaves (com o nome, o espaço de chaves, o componente que o derivou mais de uma vez, o fornecedor e o caminho de encaminhamento indicados))
A segunda coordenada segue aqui o contribuidor nos mesmos termos que acima, pelo que uma repetição dentro da saída própria de um anexo nomeia esse anexo, e não apenas o componente que o traz.
Como corrigir: onde são nomeados dois contribuidores, mudar o nome de um deles no Aggregate, para que os nomes dele derivados deixem de coincidir com os do outro. Onde o tipo de nome é component-id, cada constatação já nomeia aquilo a que se deve mudar o nome: carrying attachment "…" é a chave sob o bloco features: desse componente, e um feature "…"attached at boundary "…" é o nome sob o bloco features: dessa fronteira. Onde as duas constatações diferem apenas na fronteira que nomeiam, os dois anexos trazem um mesmo nome em duas fronteiras — mudar o nome de um deles, ou atribuir às duas fronteiras caminhos directory: distintos para que a sua saída deixe de ser fundida. Onde os dois nomes são nomes que a compilação compôs, só se podem ter encontrado depois de terem sido encurtados para caberem no destino, pelo que convém encurtar manualmente as partes de que são compostos, em vez de deixar isso à compilação. Onde ambos os nomes são derivados de algo definido explicitamente — um valor que a Recipe passa ao fornecedor, ou uma anotação que o fornecedor lê —, alterar isso, em vez disso, naquele dos dois que se controla. Onde os dois contribuidores pertencem realmente a saídas separadas, atribuir às suas fronteiras caminhos directory: distintos para que cada uma seja montada por si e os dois nomes nunca se encontrem. Onde um único contribuidor é nomeado como tendo derivado o nome mais de uma vez, as duas coisas em colisão estão ambas dentro desse único componente: encontrar os dois recursos que a sua Recipe produz cujos nomes coincidem, e alterar aquilo a partir do qual um deles é nomeado — a chave sob a qual é declarado, ou um valor a partir do qual é construído — para que o fornecedor derive um nome distinto para cada um. Onde o tipo de nome é apenas um tipo ao nível do cluster, como resource-names:ClusterRole, os documentos nomeados descrevem um único objeto no cluster, sejam quais forem os namespaces em que foram colocados: emiti-lo a partir de um único contribuidor — através de um valor que o seu chart ofereça, como uma opção para instalar as suas definições — ou, onde os dois se destinam a ser dois objetos, dar a um deles um nome próprio no chart ou no corpo que se controla; um único contribuidor nomeado duas vezes por esse objeto escreve-o sob dois namespaces, e um dos dois documentos é o que deve ser retirado.
An authored export name is one the build derives for a cross-stack reference (Um nome de exportação escrito é um que a compilação deriva para uma referência entre stacks)
O bloco Outputs: de uma Recipe cloudformation é CloudFormation escrito pelo autor, e uma entrada nele pode trazer o seu próprio Export: com um Name:; esse nome chega à stack montada exatamente como foi escrito. Separadamente, quando uma aresta uses passa de uma fronteira para outra, o fornecedor publica o valor consumido como um Output da stack com um Export sob um nome que deriva da release, da fronteira, do componente e da chave fornecida. Esta interrupção ocorre onde os dois se encontram: o nome escrito é o nome que a derivação produziu para a mesma compilação, pelo que a stack declararia um mesmo nome de exportação duas vezes a partir de dois sítios, e um nome de exportação tem de ser único.
Só a coincidência provoca uma interrupção. Declarar um nome de exportação numa entrada Outputs é suportado, e um que não coincide com nenhum nome derivado é publicado ao lado dos derivados sem qualquer comentário — em todas as entradas exceto a saída da stack na qual uma referência entre stacks publica a sua própria exportação, para uma chave que consome. Um Export: aí provoca uma interrupção, a menos que traga exatamente o nome derivado; esse caso é The output a cross-stack reference publishes on already carries an Export (A saída na qual uma referência entre stacks publica já traz um Export).
A interrupção indica o nome de exportação derivado juntamente com as quatro partes a partir das quais foi construído, para que seja possível ver qual referência entre fronteiras o produziu, e nomeia a saída da stack sob a qual se encontra a declaração — marcada como um nome que o fornecedor monta, e não como um que uma Recipe escreveu, porque o fornecedor constrói esse nome codificando o componente e a entrada nas letras e nos dígitos que um ID lógico admite, pelo que esse nome não é a string com que qualquer um dos dois foi escrito. O nome de exportação é a parte a procurar. A entrada escreve-o exatamente como a interrupção o faz, o que faz dos dois uma colisão, pelo que é a única string que aparece tanto na mensagem como nos próprios ficheiros.
A comparação restringe-se a uma única stack: os nomes de exportação que essa stack declara, comparados com os nomes derivados para as referências entre fronteiras que nela publicam. Duas stacks não são comparadas entre si, e um nome de exportação escrito como uma função intrínseca do CloudFormation é resolvido no momento da implementação, pelo que não há nenhum nome a comparar. Aquilo que um nome encontra entre as exportações já implementadas numa conta e numa região é uma propriedade da implementação, que uma compilação não observa.
Mensagem emitida. A condição nomeia o tipo de falha e a frase própria do fornecedor diz o que aconteceu; a comunicação envolvente também nomeia a aresta uses que está a ser cablada:
two things a plugin produced occupy one name in its output (duas coisas que um plugin produziu ocupam um mesmo nome na sua saída) 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 (um nome de exportação que uma ligação entre fronteiras deriva já está declarado por outra entrada Outputs na mesma stack: a ligação deriva o nome de exportação indicado para a chave provides indicada do componente indicado na fronteira indicada da Release indicada, e outra entrada Outputs da mesma stack já declara esse mesmo nome de exportação — essa declaração encontra-se sob a saída da stack indicada, um nome que este fornecedor monta, e não um que uma Recipe escreveu; cada entrada Outputs que o oculta escreve o seu nome de exportação exatamente como a interrupção, pelo que procurar esse nome nas Recipes leva à entrada — mudar o nome de exportação que a entrada declara, ou remover o bloco Export dessa entrada e deixar a ligação publicar a exportação)
Como corrigir: procurar nas Recipes o nome de exportação que a interrupção nomeia — a entrada Outputs que o declara escreve-o de forma idêntica — e depois mudar esse nome de exportação para que deixe de coincidir, ou remover o bloco Export: dessa entrada e deixar que seja a cablagem entre stacks a publicar a exportação. Removê-lo é normalmente a opção certa onde a entrada existia para exportar o mesmo valor que a aresta consome: o fornecedor publica de qualquer forma um Export para esse valor, pelo que o escrito pelo autor não acrescenta nada. Manter antes o Export: escrito e mudar-lhe o nome onde a entrada exporta o valor para um consumidor diferente que o importa sob um nome escolhido pelo autor.
The output a cross-stack reference publishes on already carries an Export (A saída na qual uma referência entre stacks publica já traz um Export)
Quando uma aresta uses passa de uma fronteira para outra, o fornecedor publica o Export do valor consumido na saída da stack que monta para o componente produtor e a chave fornecida — a mesma saída que uma Recipe de cloudformation alcança quando o seu bloco Outputs: escreve uma entrada sob essa chave. Um Export: já presente nessa saída só é mantido quando o seu Name: é exatamente o nome que o fornecedor deriva: essa é a exportação que uma referência entre stacks anterior ao mesmo valor já publicou, pelo que todos os consumidores importam esse único nome. Qualquer outro Export: nesse ponto provoca uma interrupção, porque escrever a exportação do fornecedor substituiria aquilo que foi escrito pelo autor, e manter o do autor deixaria todos os consumidores a importar um nome que a referência nunca publicou.
A interrupção ocorre perante quatro formas de Export: nessa saída:
um Name: que é uma cadeia diferente;
um Name: escrito como função intrínseca do CloudFormation, que se resolve no momento da implementação, pelo que o fornecedor não consegue ler aquilo que exprime;
um bloco Export: que não nomeia nada;
um Export: escrito como valor simples em vez de como bloco.
Mensagem emitida. A condição nomeia o tipo de falha e a frase própria do fornecedor diz o que aconteceu; a comunicação envolvente também nomeia a aresta uses que está a ser cablada:
two things a plugin produced occupy one name in its output (duas coisas que um plugin produziu ocupam um mesmo nome na sua saída) 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 (a saída da stack na qual uma ligação entre fronteiras publica a sua exportação já traz um Export que a ligação não escreveu: a ligação deriva o nome de exportação indicado para a chave provides indicada do componente indicado na fronteira indicada da Release indicada, e a saída da stack que este fornecedor monta para essa chave e esse componente apresenta o que é indicado; remover o bloco Export dessa entrada e deixar a ligação publicar a exportação que todos os consumidores importam)
<what-it-found> é um dos seguintes, pela ordem das formas acima:
already declares the export name <name> (já declara o nome de exportação 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 (já declara um nome de exportação que não é uma cadeia — um dado como função intrínseca, que se resolve no momento da implementação, pelo que este fornecedor não consegue ler aquilo que exprime) already carries an Export block declaring no export name (já traz um bloco Export que não declara nenhum nome de exportação) already carries an Export that is not a block, where CloudFormation expects one carrying a Name (já traz um Export que não é um bloco, onde o CloudFormation espera um que traga um Name)
Como corrigir: na Recipe do componente que a interrupção nomeia, encontrar a entrada Outputs escrita sob a chave fornecida que nomeia, e remover o bloco Export: dessa entrada — a cablagem entre stacks passa então a publicar a exportação que todos os consumidores importam. Onde for necessário que o valor seja também exportado com um nome próprio, para um consumidor fora desta compilação, escrever esse Export: numa entrada Outputs sob uma chave diferente: aí um nome de exportação é suportado, desde que não seja um que a compilação deriva.
Chart-name mismatch on a merged helm-chart umbrella (Nome de chart divergente num chart guarda-chuva helm-chart fundido)
Duas ou mais fronteiras contribuem para o mesmo caminho de montagem do fornecedor helm-chart, mas as suas anotações aggrega.ai/chart-name efetivas (resolvidas através da cascata de anotações das fronteiras) não coincidem. Um chart guarda-chuva do Helm tem exatamente um nome de chart; o renderizador não consegue escolher um dos candidatos em conflito.
Mensagens emitidas. É comunicada uma constatação por fronteira contribuidora, cada uma com o valor para o qual essa fronteira se resolveu, pelo que os nomes divergentes chegam um por constatação em vez de como uma única coleção impressa. A comunicação sob a qual chegam indica aquilo que têm em comum:
merged dispatch groups whose boundaries disagree on the assembly name (grupos de encaminhamento fundidos cujas fronteiras divergem quanto ao nome de montagem)
Cada constatação nomeia o valor para o qual essa fronteira se resolveu, a anotação da qual foi lido, a fronteira, o fornecedor e o caminho para o qual se fundem:
merged-path assembly has conflicting assembly-name annotation values ("<value>", annotation "<annotation>", boundary "<boundary>", provider "<provider>", dispatch path "<path>") (a montagem de caminho fundido tem valores em conflito para a anotação do nome de montagem (com o valor, a anotação, a fronteira, o fornecedor e o caminho de encaminhamento indicados))
Como corrigir: declarar uma anotação aggrega.ai/chart-name correspondente em cada fronteira contribuidora (o mecanismo de cascata torna isto DRY quando os contribuidores partilham uma fronteira mãe — declará-la uma vez na fronteira mãe), ou separar as fronteiras em caminhos directory: distintos, para que cada uma obtenha o seu próprio chart guarda-chuva.
FeatureRecipe template references a field outside its scope’s allowlist (O template de FeatureRecipe referencia um campo fora da lista de permissões do seu âmbito)
Uma FeatureRecipe com executionScope: boundary referencia um campo exclusivo de cada componente, como .context.instance_id, .context.inject ou .context.uses — campos que não têm valor significativo no âmbito de fronteira — num template que é executado uma única vez para a fronteira: os seus locals:, provides:, valuesMapping:, artifacts: ou o with: ou o when: de um passo de pipeline. A condição simétrica também se verifica: uma FeatureRecipe de âmbito de componente (a predefinição) que referencia campos .boundary.* falha no mesmo validador. A validação é executada no momento da análise em relação à lista de permissões de campos do âmbito correspondente, antes de começar qualquer trabalho de renderização. O injectMapping de uma FeatureRecipe de âmbito de fronteira não é verificado aqui: é executado uma vez para cada componente que o anexo alcança, no contexto desse componente, pelo que lê .context.*, e uma referência a .boundary nele é comunicada por «Template references a root the render context does not define (O template referencia uma raiz que o contexto de renderização não define)» mais acima.
Mensagem emitida:
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>") (o template de FeatureRecipe referencia um campo exclusivo de cada componente com executionScope: boundary (com o caminho indicado, escrito no campo indicado; o contexto de renderização define as raízes indicadas))
Uma FeatureRecipe de âmbito de fronteira cujo valuesMapping lê .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")
Como corrigir: reescrever o template com base nos campos disponíveis no âmbito, ou alterar o executionScope da FeatureRecipe. As FeatureRecipes de âmbito de fronteira referenciam .boundary.path, .boundary.boundary_name, .boundary.components, as coleções .boundary.*_uses_edges, .boundary.labels, .boundary.annotations e .boundary.feature_attachments. As FeatureRecipes de âmbito de Component referenciam .context.instance_id, .context.inject, .context.uses, .context.labels, .context.annotations. Ambos os âmbitos partilham .values, .infra, .locals, .provides, .steps e .metadata. Um parâmetro da Release não é um pilar próprio nesta superfície — chega a um template de FeatureRecipe através de uma entrada values ou infra que o referencia.
Self-inject value template references cross-node data (O template do valor de self-inject referencia dados entre nós)
Um template inject:value: ao nível do componente vai buscar dados a .context.inject ou .context.uses. O canal de inject é precisamente aquilo que esta passagem está a construir — um template dentro do próprio valor de self-inject de um componente não consegue ler a partir dele.
É o .context da superfície que o determina: traz instance_id, labels e annotations, e nada mais. .context.inject e .context.uses são, portanto, chaves que o contexto desta superfície não define, e a referência provoca uma interrupção como «Template references a root the render context does not define (O template referencia uma raiz que o contexto de renderização não define)» mais acima, no momento da análise, antes de qualquer coisa ser renderizada. O diagnóstico nomeia o mecanismo e a chave de entrega a que o template pertence, e lista as chaves que .context define aqui — pelo que a mesma comunicação abrange tanto uma tentativa real de alcançar dados entre nós como um simples erro ortográfico como {{ .context.nmae }}, que é o erro mais comum e que, de outra forma, teria sido renderizado como nada.
Mensagem emitida — o detalhe ao nível da referência; a comunicação envolvente nomeia também o nó, o mecanismo e a chave 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) (o template referencia uma raiz que o contexto de renderização não define (o template de self-inject indicado referencia o caminho indicado, o contexto define as chaves indicadas))
Cada quadro da comunicação pertence ao domínio do programador, porque um bloco inject: ao nível do componente é escrito no Aggregate.
Como corrigir: mover a cablagem entre componentes para uma entrada uses[].inject — é aí que o contexto entre nós está disponível. Manter os templates value: de self-inject ao nível do componente fechados sobre os values e a infra próprios do componente, os seus .context.instance_id / .context.labels / .context.annotations, e .metadata.
Missing template key — asymmetric policy (Chave de template em falta — política assimétrica)
O tratamento de chaves em falta depende da superfície do template. Onde uma renderização vazia termina num local delimitado — um campo de manifesto que o autor pode reler — a falta é tolerada e a leitura não renderiza nada. Onde, pelo contrário, uma renderização vazia produziria uma estrutura errada ou um veredicto errado, a superfície recusa a referência em vez de a resolver como nada.
A interpolação de parâmetros num Aggregate — as referências {{ .parameters.<key> }} que o próprio texto do Aggregate traz — é a mais precoce destas superfícies: é executada sobre o documento em bruto antes de o catálogo ser resolvido, pelo que a sua política se aplica a texto que nenhuma outra superfície viu ainda. Uma referência a um parâmetro que a Release nunca preencheu é renderizada como nada, e um pipe default ou uma guarda if sobre uma leitura destas comporta-se exatamente como faria sobre o parâmetro não preenchido. Uma referência que o template itera continua a iterar como nada, que é o que se pretende de um range sobre uma lista opcional — a menos que o texto também a imprima, caso em que provoca uma interrupção como descreve «A template reads and iterates a path that holds nothing (Um template lê e itera um caminho que não contém nada)» mais abaixo. Uma referência cujo pai está ausente — .parameters.db.host onde nenhum parâmetro db foi preenchido — continua a provocar uma interrupção, porque não há nada em que descer e fornecer um pai trocaria a interrupção por um artefacto silenciosamente errado. Um limite merece ser enunciado como limite e não como política: uma referência ancorada numa raiz que a superfície não define é deixada como está em vez de renderizada como nada, pelo que sobrevive no documento interpolado como o próprio texto de marcador de posição do motor de templates, <no value>. Nada nesta superfície provoca uma interrupção por causa disso, pelo que cada referência a parâmetro deve ser ancorada em .parameters, e um <no value> perdido deve ser lido como uma raiz mal escrita.
Os templates de caminho (directory: / subDirectory: das fronteiras da Release) são avaliados com missingkey=error. Uma referência a uma variável que a superfície não lhes fornece provoca uma interrupção no momento da análise — ver «Path-template references a variable outside the allowlist (O template de caminho referencia uma variável fora da lista de permissões)» mais acima — e o mesmo acontece com uma chave mal escrita sob .manifest, cujas chaves são declaradas. Uma referência admitida mas não definida no momento da avaliação, como uma chave de .parameters que a Release não fornece, produz um erro explícito em vez de renderizar silenciosamente uma cadeia vazia num caminho de diretório.
As assertions (num Component, numa Feature, numa Recipe ou numa FeatureRecipe) são avaliadas com missingkey=error. Uma referência a uma chave não definida provoca uma interrupção com um diagnóstico de chave inexistente que nomeia a entidade, a instância e a asserção. O rigor é o que torna uma asserção fiável: um predicado cuja referência fosse renderizada como valor vazio compararia com nada e passaria, pelo que um único erro ortográfico retiraria silenciosamente a regra que a asserção foi escrita para fazer cumprir. Como a referência isolada provoca uma interrupção antes de qualquer fallback poder ser executado, um default simples não fornece um fallback para um campo opcional nesta superfície — proteger a referência com hasKey, ou usar o helper optional, que faz diretamente a verificação de presença. Ler a chave através de index também não fornece um: index provoca uma interrupção numa chave de mapa que o mapa não contém, nomeando a chave.
Os templates de valores (valuesMapping da Recipe, entradas locals: e provides:, corpos de artifacts:, corpos de Workload, injectMapping e pipeline.with da FeatureRecipe, e templates value: de self-inject ao nível do componente) são avaliados com missingkey=zero, pelo que uma referência a uma chave não definida não interrompe a compilação — a leitura não renderiza nada, e é nada que chega ao artefacto. O que continua a provocar uma interrupção nesta superfície é uma referência que desce através de um contentor que o autor nunca forneceu — .values.tls.ca onde nenhum tls foi escrito — porque não há nada em que descer. Só a chave final de uma referência cujos contentores estão todos presentes é renderizada como nada. Um campo de nível superior que o contexto define, mas para o qual não contém nada — .workload numa Recipe que não sintetiza nenhum, .features num componente sem anexos — é renderizado como nada da mesma forma quando lido por inteiro. Uma referência é uma só referência, seja qual for a grafia: .values.list, $.values.list e (.values).list nomeiam a mesma chave, pelo que percorrê-la com range numa grafia é percorrê-la em todas, e uma chave lida de um pilar entre parênteses é renderizada, ou provoca uma interrupção, exatamente como a grafia direta. Uma chave que o template percorre com range continua a iterar como nada quando não está definida, e uma chave que o template tanto imprime como percorre provoca uma interrupção quando não está definida — ver «A template reads and iterates a path that holds nothing (Um template lê e itera um caminho que não contém nada)» mais abaixo. As proteções funcionam como esperado: {{ .values.optional_field | default "fallback" }} fornece de facto o fallback, porque um valor não definido conta como vazio para default e como falso para if. Quem precisa do discriminador entre ausente e zero — distinguir «chave ausente» de «chave presente e vazia» — usa o helper optional documentado em templates/sprig-functions.md, e lê uma dada chave de uma só maneira por template: uma chave que o mesmo template também lê como .values.<key> conta como presente, pelo que optional comunica o seu valor vazio em vez do fallback. O que esta política não abrange é uma leitura através de index: indexar um mapa com uma chave que ele não contém provoca uma interrupção que nomeia a chave, aqui como em qualquer superfície — ver «A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)» mais abaixo.
Uma coordenada source: — os campos com template de um bloco source: estruturado numa Recipe ou FeatureRecipe (version, ref, chart, module_subdir) — é avaliada com missingkey=error. Uma referência a uma chave que nada fornece provoca uma interrupção que nomeia o campo da fonte, em vez de se resolver como nada: uma versão ou um ref vazios fixariam um artefacto diferente daquele que o autor nomeou, e a fixação é o que cada compilação posterior reproduz. Esta superfície é também aquela em que o conjunto de funções disponível difere, e em que uma referência de locals: que a própria ordem de escrita do bloco recusa provoca uma interrupção antes de qualquer coisa ser avaliada — ver abaixo.
Os contratos de parâmetros tipados detetam os casos de parâmetro obrigatório em falta e de violação de contrato na camada de contrato de parâmetros, antes de a interpolação ser executada — ver «Parameter type mismatch / contract violation (Tipo de parâmetro incompatível / violação de contrato)» mais acima.
O conjunto de helpers é o mesmo em templates de valores, templates de caminho e asserções: as funções do Sprig mais as próprias do Aggrega (optional e capitalizedWords). O fail do Sprig está entre elas, pelo que um template de valores pode parar a compilação com uma mensagem própria, como descreve «A value template failed while it ran (Um template de valores falhou durante a execução)» mais abaixo; uma asserção é a superfície escrita para isso, já que interromper a compilação é todo o seu propósito. Entre essas três, o que difere é a política de chaves em falta — optional também está disponível num template de caminho, onde lê uma chave de .parameters sem que a política estrita seja acionada primeiro. A resolução de uma coordenada source: difere no próprio conjunto de funções, e tem a sua própria subsecção mais abaixo. A interpolação de parâmetros num Aggregate oferece apenas as funções do Sprig, pelo que nenhum dos dois helpers do Aggrega está aí disponível. Uma função lê da mesma forma em cada uma destas superfícies, incluindo a coordenada e a interpolação: index, que provoca uma interrupção nomeando a chave quando o mapa que lê não a contém.
A mensagem que uma falta num template de caminho imprime é citada sob a entrada que documenta essa condição, «Path-template references a variable outside the allowlist (O template de caminho referencia uma variável fora da lista de permissões)» mais acima, pelo que é escrita uma única vez em vez de repetida aqui.
Como corrigir: para faltas em templates de caminho, corrigir o nome do campo para um que conste da lista de permissões documentada em path-template-variables.md. Para uma falta numa asserção, corrigir a referência — a maioria das comunicações é uma chave mal escrita — ou, onde o campo for realmente opcional, protegê-lo com hasKey ou usar o helper optional; envolver a referência isolada num default não elimina a interrupção, porque a referência se resolve antes de o fallback ser executado, e lê-la através de index também não, porque index provoca uma interrupção numa chave que o mapa não contém. Para faltas em templates de valores onde a renderização vazia não é desejada, usar o helper optional ou fornecer a chave em falta como uma declaração parameters.* tipada no Aggregate com um valor da Release, como uma entrada provides: de um Component de origem cablada através de uses[].inject, ou como uma entrada locals: na mesma entidade.
Resolving a source: coordinate registers a narrower function set (A resolução de uma coordenada source regista um conjunto de funções mais restrito)
Um bloco source: estruturado é resolvido para que o artefacto que nomeia possa ser fixado, e essa resolução regista os helpers próprios do Aggrega e nada mais — optional e capitalizedWords estão disponíveis, e index provoca uma interrupção numa chave de mapa que o mapa não contém exatamente como acontece quando a Recipe renderiza; as funções do Sprig não. Das superfícies em que uma Recipe ou FeatureRecipe escreve templates, esta é a única cujo conjunto de funções difere, pelo que uma expressão que renderiza corretamente noutro ponto da mesma Recipe pode ser recusada aqui. O conjunto mais restrito é deliberado: o que é fixado é decidido pelos values e pelo infra que o autor fornece, e as funções do Sprig incluem algumas que leem o relógio, o ambiente, uma fonte aleatória ou a rede.
Chamar uma função do Sprig num campo source:, ou numa entrada locals: que esse campo lê, provoca uma interrupção no momento da análise. O diagnóstico tem como cabeçalho E0111 e nomeia a entrada, o campo source: que a lê, a função que não conseguiu resolver e os helpers que esta superfície regista:
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 (resolução: análise do template na entrada de locals indicada, lida pelo campo source indicado: resolução: erro de análise do template da fonte (causa: a função indicada não está definida); um campo source, e cada entrada de locals que lê, é avaliado quando a fonte é resolvida apenas com os helpers próprios do Aggrega (optional, capitalizedWords e index), e não com as funções do Sprig que uma renderização acrescenta; escrever o valor sem essa função, ou mover o valor para uma entrada de locals que nenhum campo source lê)
Um campo source: que chama diretamente a função é comunicado da mesma forma, nomeando apenas o campo.
O alcance são as entradas que a coordenada lê. Resolver uma coordenada avalia cada entrada locals: que um campo source: lê, e cada entrada que uma entrada dessas lê por sua vez — e nenhuma outra. Uma entrada que nenhum campo source: alcança não é avaliada, analisada nem verificada enquanto a fonte é resolvida, pelo que uma entrada de locals de que a renderização precisa — uma que faz aritmética com as funções do Sprig, ou que nomeia um recurso a partir de .context.instance_id — não tem qualquer efeito na fixação do artefacto; é avaliada, e qualquer defeito nela é comunicado, quando a Recipe renderiza. As entradas que um campo lê são decididas a partir do seu texto, pelo que um campo que lê .locals de uma forma que não nomeia nenhuma entrada específica — {{ index .locals "version" }}, o bloco inteiro passado a optional ou associado a uma variável — faz com que, em vez disso, todas as entradas sejam avaliadas, e o diagnóstico de uma entrada que alcança dessa forma indica-o: em vez de read by <field> diz evaluated for <field>, which reads the locals block as a whole rather than by entry, so every entry is evaluated.
Duas formas ficam fora desta superfície, e saber em qual delas uma Recipe está explica porque é que a mesma expressão é aceite numa Recipe e recusada noutra:
Um source: escrito como cadeia simples — um URI ou um caminho local em vez de um mapa — é tomado tal como está, pelo que não tem campos a avaliar e o bloco locals: não é de todo resolvido aqui.
Uma entidade que não declara nenhum source: não resolve nenhuma coordenada, pelo que o seu bloco locals: é resolvido apenas para a renderização própria dessa entidade, onde se aplica o conjunto completo de funções.
O contrato de ordem das referências é aqui o mesmo para cada entrada que a coordenada lê. Resolver uma coordenada recusa as mesmas referências que uma renderização recusa em cada entrada que avalia: uma entrada que lê uma entrada irmã que o bloco declara mais abaixo, e qualquer template que lê uma chave que o bloco não declara. Ambas comunicam as condições documentadas mais acima em «locals: entry references a sibling defined later in the same block (Uma entrada de locals referencia uma entrada irmã definida mais abaixo no mesmo bloco)» e «locals: key does not exist (A chave de locals não existe)» — a mesma condição, com o mesmo remédio, seja qual for a resolução que a alcançou primeiro — e a comunicação nomeia o campo source: para o qual a entrada foi avaliada. Um defeito numa entrada que nenhum campo source: lê é recusado quando a Recipe renderiza, sob a mesma condição.
O que esta superfície deixa passar é uma entrada que uma coordenada realmente não consegue resolver: uma que lê dados que só existem enquanto um artefacto é renderizado, sendo .context.instance_id o caso para o qual isto existe. Uma entrada destas é ignorada, pelo que uma Recipe cuja coordenada alcança uma delas num ramo que não percorre continua a ser fixada. Onde a própria coordenada precisava dessa entrada, a resolução provoca uma interrupção que nomeia o campo source: — a comunicação de chave em falta descrita mais acima para esta superfície, com o cabeçalho E0110 — e cita, ao lado da chave que não conseguiu ler, porque é que essa entrada não contém aqui nenhum valor:
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") (resolução: avaliação do template no campo source indicado: resolução: falha de avaliação do template da fonte no momento do lock (causa: o mapa não tem nenhuma entrada para a chave indicada); lê a entrada de locals indicada, que não pôde ser avaliada aqui (causa: o mapa não tem nenhuma entrada para a chave context))
Nem um campo source: nem uma entrada locals: que ele lê podem ler .provides. Um bloco locals: alimenta um bloco provides: e nunca o contrário, pelo que um template nesta superfície que lê .provides é recusado como a referência inversa que é, em vez de se resolver como nada. A recusa não é uma ausência no momento do lock que uma fase posterior satisfaria — nenhuma ordem torna a referência válida — pelo que é comunicada da mesma forma onde quer que a coordenada seja resolvida. O diagnóstico tem como cabeçalho E0112; nomeia o campo, ou a entrada e o campo que a lê, diz o que está errado na referência e indica a superfície que a expressão pode ler em vez disso:
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) (o template de versão da fonte no campo source indicado referencia .provides, o que é uma referência inversa inválida (locals alimenta provides, nunca o contrário) — refatorizar para ler apenas .values e .infra (e .locals sobre os mesmos): resolução: o template da fonte referencia .provides (referência inversa inválida))
Onde surge a interrupção: enquanto o lockfile é preenchido ou atualizado — aggrega pull, ou uma compilação que o preenche (--auto-pull, --upgrade ou a definição auto_pull do workspace). Cada falha é comunicada como um único diagnóstico, com o código do que correu mal como cabeçalho — E0111 para um template que não passa na análise, E0112 para uma referência a .provides, E0110 para um template que foi analisado e não pôde ser avaliado — tanto no terminal como num editor ligado a aggrega serve. Uma chave em falta num campo source:, ao contrário de uma função indisponível, é comunicada no momento da execução e não da análise, nomeando o campo e a chave que não pôde ser lida.
Como corrigir:optional está registado nesta superfície e em cada template de valores, template de caminho e asserção, o que faz dele a escolha portável — {{ optional .values "chart_version" "25.0.8" }} em vez de {{ default "25.0.8" .values.chart_version }}. Ler a diferença semântica antes de substituir: optional é acionado quando a chave está ausente, enquanto default é acionado quando o valor está vazio, pelo que uma chave escrita como cadeia vazia ou como zero mantém o valor escrito com optional e é substituída com default. Onde a expressão precisa realmente de uma função do Sprig — remodelar uma cadeia em vez de fornecer um fallback — mantê-la fora daquilo que a coordenada lê: numa entrada locals: que nenhum campo source: lê, ou na superfície que a consome (valuesMapping, um corpo de Workload, uma entrada artifacts:).
A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)
Um template lê um mapa através de index — {{ index .values "replicas" }}, ou {{ index .context.inject.env $apiKeyVar }} com um nome de chave que o template calculou — e o mapa não contém a chave pedida. index provoca aí uma interrupção e nomeia a chave, em cada superfície que avalia um template: templates de valores, entradas locals: e provides:, templates de caminho, asserções, uma coordenada source: estruturada, a interpolação de parâmetros num Aggregate e os predicados validate: dos seus parâmetros, e os predicados x-aggrega-when: e x-aggrega-validate: de um esquema.
Esta é uma propriedade apenas de index, e a política de chaves em falta de nenhuma superfície a altera. Uma leitura com ponto de uma chave não definida sob um pilar aberto continua a não renderizar nada num template de valores, como descreve «Missing template key — asymmetric policy (Chave de template em falta — política assimétrica)» mais acima, e um template que testa se o autor forneceu uma chave destas não é afetado. O que provoca a interrupção é pedir a index uma chave que o mapa não contém. index é a forma como um template alcança uma chave cujo nome calcula — uma credencial lida sob o nome de variável que a Recipe consumidora escolheu, por exemplo — e, sem a interrupção, essa leitura colocaria no artefacto o texto de marcador de posição do motor de templates <no value> enquanto a compilação é bem-sucedida: um servidor iniciado com esse texto como chave. Qualquer outra resposta que index dá é a do próprio motor de templates: uma posição numa lista ou numa cadeia, uma posição fora do intervalo, uma chave que o mapa contém — incluindo uma cujo valor é null, que imprime <no value>.
Mensagem emitida, como última linha da comunicação — os quadros acima dela nomeiam o nó e o campo em que o template se encontra, e num template de valores de uma Recipe ou FeatureRecipe o cabeçalho traz o código desta condição:
template: <template>:<line>:<column>: executing "<template>" at <index <map> <key>>: error calling index: template indexes a map with a key the map does not hold (key "<key>"). read a key that may be absent through a function that tests for it first, such as optional, get or hasKey (template: execução do template indicado, na linha e na coluna indicadas, na expressão index indicada: erro ao chamar index: o template indexa um mapa com uma chave que o mapa não contém (com a chave indicada). ler uma chave que pode estar ausente através de uma função que primeiro testa a sua presença, como optional, get ou hasKey)
Numa superfície que comunica uma falha de template sob uma condição própria — uma entrada provides: («A provides: template could not be evaluated (Não é possível avaliar um template de provides)»), a interpolação de parâmetros («A {{ .parameters.* }} reference cannot be interpolated (Uma referência a parâmetros não pode ser interpolada)»), um predicado de esquema («An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Não é possível avaliar um predicado)»), uma coordenada source: («Resolving a source: coordinate registers a narrower function set (A resolução de uma coordenada source regista um conjunto de funções mais restrito)») — o cabeçalho traz o código dessa condição e a linha acima é o motivo que traz, incluindo a chave.
Como corrigir: decidir se a chave pode legitimamente estar ausente.
Pode. Lê-la através de uma função que primeiro testa a sua presença: {{ optional .values "replicas" 1 }} devolve o fallback quando a chave está ausente e o valor, seja ele qual for, quando está presente; o get do Sprig devolve uma cadeia vazia para uma chave ausente; hasKey testa sem ler. optional está registado em todas as superfícies exceto na interpolação de parâmetros e nos predicados de um parâmetro ou de um esquema, que oferecem get e hasKey do Sprig; uma coordenada source: regista optional e não o Sprig.
Não pode. Fornecê-la. A chave que a mensagem nomeia é a que o template pediu, pelo que as causas habituais são uma chave publicada sob outro nome — uma credencial cuja key não é o nome de variável que a Recipe lê — uma chave mal escrita no template ou nos valores escritos, e uma ligação que entregaria a chave e não está cablada.
A template reads and iterates a path that holds nothing (Um template lê e itera um caminho que não contém nada)
Um template imprime um caminho tal como está e também percorre o mesmo caminho — "user": "{{ .values.user }}" e "users": "{{ range .values.user }}…{{ end }}" num mesmo valuesMapping, por exemplo — e os dados não contêm nada aí: a chave não está definida, contém null, ou é um campo de nível superior que o contexto define e para o qual não contém nada, como .workload numa Recipe que não sintetiza nenhum. A compilação é interrompida antes de o template ser executado e nomeia o caminho, em cada superfície que renderiza um valor não definido como nada: os templates de valores que «Missing template key — asymmetric policy (Chave de template em falta — política assimétrica)» enumera mais acima, e a interpolação de parâmetros num Aggregate.
Cada leitura isolada tem uma resposta. Um valor não definido que é impresso não renderiza nada, e um que é percorrido com range não itera nada. Um caminho lido das duas formas não pode ter nenhuma das duas: renderizá-lo como nada faria o range falhar sobre texto, e deixá-lo não definido imprimiria no artefacto o texto de marcador de posição do motor de templates <no value> enquanto a compilação é bem-sucedida. Por isso, nenhuma das duas respostas é dada e, em vez disso, a compilação para.
O que conta como imprimir o caminho é restrito, e a linha é traçada onde o template certamente o imprime:
É impresso quando uma ação consiste no caminho e em nada mais — {{ .values.user }}, {{ $.values.user }}, {{ (.values).user }}, ou uma variável associada ao caminho, {{ $u }} depois de {{ $u := .values.user }} — num ponto que o template alcança sempre que é executado.
Não é impresso quando a leitura se encontra dentro de um corpo if, with ou range ou de um ramo else, porque a execução dessa leitura depende de uma condição, e a condição pode ser precisamente o teste que a impede de encontrar nada — pelo que {{ if .values.user }}{{ .values.user }}{{ end }} ao lado de um range .values.user renderiza como sempre. Também não é impresso quando é o próprio teste de uma guarda, a atribuição de uma variável ou um argumento de uma função — {{ .values.user | quote }}, {{ toYaml .values.user }} — cuja saída é a resposta da função e não o marcador de posição.
Uma impressão dentro de um corpo que é de facto executado sobre um caminho que não contém nada continua a escrever <no value>, algo que esta verificação não alcança. Uma grafia de um caminho é o mesmo caminho que qualquer outra, pelo que uma impressão numa grafia e um range noutra são julgados em conjunto, e a mensagem cita a grafia que o template escreveu primeiro. Um caminho que contém um valor é impresso e iterado como sempre, e um caminho cujo pai não contém nada fica entregue à interrupção que descer através de nada já provoca.
Mensagem emitida, como última linha da comunicação — os quadros acima dela nomeiam o nó e o template, e o cabeçalho traz o código desta condição:
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 (o template lê um caminho como valor e itera-o, e os dados não contêm nada nesse caminho (com o caminho indicado). fornecer um valor no caminho, proteger a leitura impressa com um if ou um with sobre o caminho, ou lê-lo de uma só forma)
A interpolação de parâmetros num Aggregate também comunica a mesma linha sob o código desta condição. Uma entrada provides: comunica uma falha de template sob «A provides: template could not be evaluated (Não é possível avaliar um template de provides)», pelo que aí o cabeçalho traz o código dessa condição e a linha acima é o motivo que traz, incluindo o caminho.
Como corrigir: decidir qual das duas leituras o template pretende.
O caminho tem de estar presente. Fornecê-lo — nos values: do Aggregate, no infra: da Release ou no parâmetro que a Release preenche — ou declará-lo obrigatório no esquema que o rege, para que a sua ausência seja comunicada onde é escrito.
O caminho pode estar ausente. Proteger a leitura impressa: {{ with .values.user }}{{ . }}{{ end }} ou {{ if .values.user }}{{ .values.user }}{{ end }} não imprime nada quando não está definido, e o range ao lado continua a iterar como nada.
Uma leitura basta. Ler o caminho de uma só forma — um range que também escreve aquilo de que precisa, ou uma impressão através de uma função como toYaml ou join que responde por si mesma por um valor não definido.
A value template failed while it ran (Um template de valores falhou durante a execução)
O template de valores de uma Recipe ou de uma FeatureRecipe — um dos templates que «Missing template key — asymmetric policy (Chave de template em falta — política assimétrica)» mais acima enumera, entre eles um corpo de Workload, um corpo de artifacts: ou uma entrada locals: — foi analisado, começou a ser executado e parou antes de produzir o seu texto. O que o parou é o motivo próprio do motor de templates, que a interrupção traz por baixo de si: uma referência que desce através de um contentor que nada forneceu, como {{ .values.tls.ca }} onde nenhum tls foi escrito; uma comparação entre valores de dois tipos, como {{ if eq .context.instance_id 1 }}, que compara texto com um número e provoca uma interrupção com cannot compare text with a number; ou uma chamada ao fail do Sprig, que um template de valores pode fazer para recusar uma entrada com uma mensagem própria.
Quatro falhas nestes templates são, em vez disso, comunicadas sob condições próprias. Uma entrada provides: é comunicada sob «A provides: template could not be evaluated (Não é possível avaliar um template de provides)» mais abaixo, com esta frase e o motivo do motor dentro da sua mensagem. Uma leitura através de index de uma chave que o mapa não contém é comunicada sob «A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)» mais acima. Um template que imprime e percorre com range um mesmo caminho que não contém nada é recusado antes de ser executado, sob «A template reads and iterates a path that holds nothing (Um template lê e itera um caminho que não contém nada)» mais acima. E um template que não pode ser analisado para antes de ser executado, pelo que não é esta condição.
Mensagem emitida — os quadros acima dela nomeiam a instância do componente e o template, como recipe "<recipe>" workload template ou Recipe "<recipe>" locals["<key>"], e a linha própria do motor de templates segue por baixo:
a value template failed while it ran (um template de valores falhou durante a execução)
A linha do motor diz template: <template>:<line>:<column>: executing "<template>" at <<expression>>: <reason> — para uma chamada a fail, error calling fail: <the message the template wrote>. A compilação comunica a interrupção sob uma etiqueta CATALOG_ERROR, porque o template é escrito pelo autor da Recipe ou da FeatureRecipe. aggrega pull depara-se com a mesma falha quando renderiza a Release para descobrir as entradas externas que esta lê: comunica a falha, grava ainda assim as fixações de dependências do lockfile e avisa que as fixações das entradas externas podem estar incompletas; a compilação, por sua vez, é interrompida por ela.
Como corrigir: ler o motivo do motor no final da comunicação — nomeia o template, a linha e a coluna, e a expressão em que parou. Para um contentor que nada forneceu, fornecê-lo, ou proteger a leitura para que nunca desça a algo ausente: {{ with .values.tls }}{{ .ca }}{{ end }}, ou o helper optional. Para dois tipos comparados, comparar o que é comparável — um número com um número escrito sem aspas, texto com texto escrito entre aspas — ou converter um dos lados em texto com toString. Para uma chamada a fail, a mensagem é do autor do template e diz aquilo de que a Recipe precisa: fornecer-lho, ou mapear o componente para uma Recipe que aceite aquilo que foi escrito.
A governance plugin rejected the build (Um plugin de governação rejeitou a compilação)
Um operador pode anexar um plugin de governação num papel de veredicto, sobre o grafo que o compilador construiu ou sobre os artefactos que renderizou. Um plugin destes lê e devolve um veredicto. O anfitrião não tem nenhum caminho que aplicaria uma alteração vinda dele, pelo que um papel de veredicto pode rejeitar uma compilação e não pode reescrevê-la para a tornar conforme — a rejeição é tudo o que pode fazer, e o que alterar fica a cargo de quem a lê.
Só um veredicto de interrupção para a compilação. Os veredictos de aviso e informativos são comunicados e a compilação continua. Cada veredicto de interrupção que um plugin devolveu é comunicado, pela ordem em que o plugin os emitiu, pelo que uma única execução dá a conhecer todos eles.
A mensagem que uma compilação imprime é a do próprio plugin, apresentada exatamente como foi devolvida e enquadrada apenas pelo plugin que a devolveu — pelo que o quão específica é, e o quão útil é para agir, cabe ao plugin decidir, e não ao compilador. Qualquer detalhe opcional que o veredicto trouxe segue entre parênteses retos, com cada parte nomeada: um código, um identificador de regra, uma classificação, uma referência de origem, uma localização, uma sugestão. A condição sob a qual é registado é policy violation, que é aquilo em que um código curto no cabeçalho do diagnóstico se resolve.
A recusa é atribuída ao anexo de governação, e não a um dos seus documentos, pelo que não traz nenhuma posição de ficheiro: não há nenhuma chave que a tenha produzido, e a resposta é satisfazer a política ou reconsiderar o anexo.
Mensagem emitida:
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>] (o plugin de política indicado rejeitou a compilação: com a mensagem própria do plugin e, entre parênteses retos, o código, o identificador de regra, a classificação, a referência de origem, a localização e a sugestão indicados)
A parte entre parênteses retos só está presente onde o veredicto trazia detalhes, e cada parte dentro dela só onde o plugin a definiu.
Como corrigir: ler a mensagem do plugin e a sugestão, onde a tiver fornecido. Onde a constatação estiver correta, alterar aquilo a que se opõe. Onde a política não se deva aplicar a esta Release, trata-se de uma questão sobre o anexo: os anexos de governação configuram-se sob plugins.governance na configuração do espaço de trabalho, e qual plugin é executado em qual papel é uma decisão do operador, e não algo que um documento possa sobrepor.
A governance attachment’s settings do not match the plugin’s declared schema (As definições de um anexo de governação não correspondem ao esquema declarado do plugin)
Um plugin de governação pode declarar um esquema para as definições que o seu anexo lhe passa. As definições escritas sob with.settings do anexo são verificadas face a esse esquema antes de o plugin ser invocado, pelo que um anexo mal configurado é comunicado como o defeito de configuração que é, em vez de chegar ao plugin como uma entrada malformada e voltar como aquilo que o plugin fizer dela.
Essa ordem é o propósito da verificação. Torna também esta condição claramente distinta de uma rejeição: o plugin não foi executado, nenhum veredicto foi alcançado e nada da compilação foi julgado. Um plugin que não declara nenhum esquema de definições aceita quaisquer definições, pelo que um anexo a um desses plugins nunca encontra esta condição.
A verificação abrange todos os papéis de governação. Um anexo escrito em ir-verdict, render-verdict, label-transform ou annotation-transform tem as suas definições verificadas face ao esquema antes de o plugin ser invocado — with.settings é a mesma chave escrita em todos os papéis, e todos os papéis a leem primeiro face ao esquema. Um papel de transformação é executado onde a compilação o aplica, o que, numa compilação que faz primeiro um pull, acontece durante esse pull, pelo que aí a mensagem começa pelo passo que o invocou, como em auto-pull: label-transform:.
Mensagem emitida — o papel em que o anexo foi escrito e o plugin que nomeia, depois a frase fixa, depois aquilo que a verificação do esquema encontrou:
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: o plugin indicado: with.settings não satisfaz o esquema de definições declarado do plugin: com o resultado indicado da verificação do esquema: as definições do anexo de política não satisfazem o esquema de definições declarado do plugin)
A cláusula inicial diz render-verdict para um anexo escrito nesse papel. Aquilo que a verificação do esquema encontrou é a comunicação própria do validador do esquema e ocupa mais de uma linha.
Como corrigir: corrigir as definições sob with.settings desse anexo em plugins.governance. O detalhe a meio da mensagem nomeia a chave com defeito e aquilo que o esquema esperava aí; a referência própria do plugin documenta as definições que declara.
A pipeline step failed (Um passo de pipeline falhou)
Uma FeatureRecipe pode declarar um pipeline: uma sequência de passos, cada um dos quais invoca um export de plugin sobre os documentos que o nó emitiu, para que uma Feature possa moldar a saída que a Recipe própria do componente produziu. Esta é a condição sob a qual um passo comunica quando falha por qualquer motivo que não seja um patch que endereça algo que o conjunto de documentos não contém, que tem uma comunicação própria mais abaixo.
Aquilo que falhou é nomeado pelo id do passo e pelo seu índice, e a cláusula que se segue diz qual a parte que cedeu: a renderização da entrada with do passo, a própria chamada, uma saída que o anfitrião não conseguiu ler, um erro que o plugin devolveu, um diagnóstico com severidade de erro que o plugin emitiu, um patch que o motor de patches rejeitou, ou um patch que nomeia um âmbito que o percurso não tem.
Um passo que falhou é revertido por inteiro. Os documentos são repostos como estavam antes de o passo ser executado, e as saídas próprias do passo são descartadas com eles, pelo que o when ou o with de um passo posterior não pode ler um resultado parcial. Um passo declarado optional: true é então comunicado como um aviso e o percurso continua; um passo que não é opcional para a compilação. O que optional:não tolera é um contrato declarado violado — ver a entrada mais abaixo.
Mensagens emitidas:
pipeline step failed: step "<id>" (index <n>) with: <what the render could not do> (o passo de pipeline falhou: na entrada do passo indicado, com o índice indicado, a renderização não conseguiu fazer o que é indicado) pipeline step failed: step "<id>" (index <n>) invoke: <what the call could not do> (o passo de pipeline falhou: na invocação do passo indicado, com o índice indicado, a chamada não conseguiu fazer o que é indicado) pipeline step failed: step "<id>" (index <n>) error diagnostic: <the plugin's message> (o passo de pipeline falhou: o passo indicado, com o índice indicado, emitiu um diagnóstico de erro com a mensagem do plugin indicada) pipeline step failed: scope "<scope>" key "<key>": <what the patch engine refused> (o passo de pipeline falhou: no âmbito e na chave indicados, o motor de patches recusou o que é indicado) pipeline step failed: unknown patch scope "<scope>" (o passo de pipeline falhou: âmbito de patch desconhecido, o indicado)
Como corrigir: ler o id do passo e depois a cláusula a seguir ao índice — diz qual a metade do passo a examinar. Uma falha de with é um template no bloco with: próprio do passo, e corrigi-la cabe a quem o escreveu. Um diagnóstico de erro são as próprias palavras do plugin sobre a entrada. Um patch recusado e um âmbito desconhecido são a saída do plugin face àquilo que o nó emitiu, e cabem ao autor do plugin. Onde um passo tem realmente permissão para falhar — um enriquecimento opcional, e não uma transformação obrigatória — declará-lo optional: true, tendo presente que isso tolera uma falha, e não um contrato quebrado.
A pipeline step’s typed input or output does not satisfy its declared contract (A entrada ou a saída tipada de um passo de pipeline não satisfaz o seu contrato declarado)
Um export de plugin pode declarar um esquema para a entrada que recebe e para as saídas que devolve. Ambos são verificados: o valor with renderizado antes da chamada, e as saídas devolvidas depois dela. Um diagnóstico cuja severidade o contrato partilhado não declara é recusado nos mesmos termos.
Isto provoca uma interrupção mesmo para um passo declarado optional: true, e essa distinção é todo o motivo pelo qual a condição é separada de uma falha do passo. Opcional tolera um passo que não conseguiu fazer o seu trabalho — uma chamada que falhou, um plugin que levantou uma objeção. Não tolera uma saída que o anfitrião não consegue encaminhar, nem uma entrada que nunca teve a estrutura que o export dizia receber: um contrato declarado é um compromisso, e uma compilação que saltasse silenciosamente um passo cujo contrato foi quebrado estaria a comunicar sucesso sobre uma Feature que não fez nada.
Mensagens emitidas:
pipeline step "<id>"with input does not satisfy the declared input contract: <what the schema check found>: pipeline step typed-I/O contract violation (a entrada do passo de pipeline indicado não satisfaz o contrato de entrada declarado: com o resultado indicado da verificação do esquema: violação do contrato de E/S tipada do passo 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 (o passo de pipeline indicado devolveu saídas que não satisfazem o contrato de saída declarado: com o resultado indicado da verificação do esquema: violação do contrato de E/S tipada do passo de pipeline)
e, para uma severidade de diagnóstico que o contrato não declara, que chega dentro do quadro da falha do passo:
pipeline step failed: step "<id>" (index <n>): <the severity the host could not route>: pipeline step typed-I/O contract violation (o passo de pipeline falhou: o passo indicado, com o índice indicado: com a severidade indicada que o anfitrião não conseguiu encaminhar: violação do contrato de E/S tipada do passo de pipeline)
Onde o template with do passo lê um valor declarado sensível, uma violação da entrada não nomeia nenhum valor. Aquilo que a verificação do esquema encontrou é substituído por cada posição com falha e pela palavra-chave que a recusou, fechadas por um aviso que nomeia o motivo — at '/origin': pattern (the value is withheld because the template that rendered this input reads a value declared sensitive) — pelo que o campo a corrigir continua a ser nomeado. Ver vocabulary/compact-form-authoring.md «O que uma recusa diz sobre um valor declarado».
Como corrigir: para uma violação da entrada, corrigir o bloco with: do passo de acordo com o esquema que o seu export declara — o detalhe nomeia o campo e aquilo que era esperado. Uma violação da saída e uma severidade não declarada cabem ao plugin corrigir; a declaração do passo não é o que está errado, pelo que marcá-lo como opcional não elimina nenhuma das duas.
A pipeline patch addresses a document the set does not hold, or one with no tree to address (Um patch de pipeline endereça um documento que o conjunto não contém, ou um sem árvore a endereçar)
Um passo de pipeline endereça um documento por um âmbito e uma chave, e duas formas de endereço são recusadas.
O conjunto não o contém. O passo aplicou um patch a um par de âmbito e chave que não está entre os documentos que recebeu. Nada seria editado, pelo que, em vez de aplicar um patch a nada e comunicar sucesso, o percurso para:
pipeline patch targets a document not present in the set: scope "<scope>" key "<key>" (o patch de pipeline aponta para um documento que não está presente no conjunto: com o âmbito e a chave indicados)
Não traz nenhuma árvore a endereçar. Algumas unidades não têm nenhuma estrutura para a qual um patch possa apontar — um corpo binário, texto livre, uma região que o fornecedor não consegue percorrer em segurança. Uma unidade destas é ainda assim entregue ao passo, marcada com o seu tipo de suporte e os seus bytes, para que possa ser selecionada e emitida por inteiro; o que não pode é receber um patch, porque não há nada face ao qual um caminho se possa resolver. Um patch contra uma delas para, em vez de ser ignorado silenciosamente:
pipeline patch targets an opaque (non-structured) unit: scope "<scope>" key "<key>" (o patch de pipeline aponta para uma unidade opaca, não estruturada: com o âmbito e a chave indicados)
O que conta como estruturado é a leitura própria que o fornecedor faz da unidade, e não um teste fixo, pelo que o mesmo conteúdo pode ser endereçável sob um fornecedor e opaco sob outro.
Ambas são recusas próprias do percurso, e uma compilação comunica-as no nó cujo pipeline aplicou o patch, pelo que a mensagem acima chega por baixo de uma interrupção que nomeia esse nó. Essa interrupção é a forma que para a compilação das mesmas duas falhas de endereçamento, documentada sob «A pipeline step addresses documents the node does not have (Um passo de pipeline endereça documentos que o nó não tem)» mais abaixo — que abrange também o terceiro endereço com o qual um passo pode não alcançar nada, um pedido dos documentos de um componente anfitrião num ponto em que não há nenhum.
Como corrigir: ambas cabem ao autor do plugin, e não a quem escreve os documentos. Um passo recebe o conjunto de documentos sobre o qual está a ser executado e pode ler quais as chaves que contém, pelo que um alvo ausente é um passo a endereçar um documento que este nó não emitiu — aplicar o patch a um documento que lá esteja, ou emitir primeiro aquele que se pretendia e aplicar-lhe o patch num passo posterior. Para uma unidade opaca, substituir o patch por uma emissão da unidade inteira: um corpo opaco é substituído, e não editado.
A patch’s test operation did not match the document (A operação de teste de um patch não correspondeu ao documento)
Um patch pode conter uma operação test, que afirma o que está num caminho antes de as operações seguintes serem aplicadas. O motor recusa o patch inteiro quando a afirmação não se verifica, e é isso que torna um patch condicional realmente condicional, e não otimista: um plugin que testa antes de editar está a dizer que não tocará num documento que não reconhece.
Duas formas são comunicadas sob esta condição. Não há absolutamente nada no caminho, o que a mensagem diz. Ou há um valor e não é o afirmado, o que é comunicado como a simples recusa — não é citado nem o valor afirmado nem o encontrado.
Mensagens emitidas:
jsonpatch: test operation failed: no value at path (jsonpatch: a operação de teste falhou: nenhum valor no caminho) jsonpatch: test operation failed (jsonpatch: a operação de teste falhou)
Onde a saída de um passo de pipeline continha o patch, a recusa chega por baixo da falha desse passo, nomeando o passo. Onde o continha o patch de um plugin label-transform, chega por baixo da recusa do patch de labels.
Como corrigir: a falha é do plugin, e não dos documentos. Um teste que esperava um valor que o documento não tem significa geralmente que o plugin está a ser executado sobre uma estrutura para a qual não foi escrito — a saída de outro fornecedor, ou um documento que um passo anterior do mesmo pipeline já alterou. Onde a correção do patch couber a quem lê, flexibilizar o teste para aquilo que o documento realmente contém, ou fazer com que a condição when do passo salte o caso em vez de o testar dentro do patch.
A workload: form and the fields beside it do not agree (A forma de uma carga de trabalho e os campos ao lado dela não concordam)
Um workload: declara uma form: — a estrutura daquilo que é executado, expressa em termos que todos os destinos compreendem, e não no vocabulário de um único destino. Alguns campos só fazem sentido numa forma, e uma forma declarada sem o campo de que precisa não tem nada coerente para renderizar. Ambas as direções são verificadas, antes de qualquer destino traduzir a carga de trabalho, pelo que o desacordo é comunicado uma única vez face ao que foi escrito, e não uma vez por destino nas palavras que cada destino tem para ele.
São aplicados cinco emparelhamentos, e cada um comunica uma frase própria que nomeia as duas metades e o que escrever:
workload declares a persistentTemplate volume but is not form: stateful; declare form: stateful (a carga de trabalho declara um volume persistentTemplate, mas não é form: stateful; declarar form: stateful) workload is form: reference but declares no endpoint; set endpoint to the external host or URL the reference points at (a carga de trabalho é form: reference, mas não declara nenhum endpoint; definir endpoint como o host externo ou o URL para onde a referência aponta) workload declares an endpoint but is not form: reference; declare form: reference or remove the endpoint (a carga de trabalho declara um endpoint, mas não é form: reference; declarar form: reference ou remover o endpoint) workload is form: scheduled but declares no schedule; set schedule to a 5-field cron expression or an @-macro (e.g. @daily) (a carga de trabalho é form: scheduled, mas não declara nenhum agendamento; definir schedule como uma expressão cron de 5 campos ou uma macro @, p. ex. @daily) workload declares a schedule but is not form: scheduled; declare form: scheduled or remove the schedule (a carga de trabalho declara um agendamento, mas não é form: scheduled; declarar form: scheduled ou remover o agendamento)
Cada uma é posicionada na instância do componente cuja carga de trabalho estava a ser lida, e comunicada como uma falha de tradução, porque o desacordo é entre dois campos de um único bloco escrito pelo autor.
As condições sob as quais são registadas, que são aquilo em que os seus códigos curtos se resolvem, são persistentTemplate volume requires form: stateful, form: reference requires an endpoint, endpoint requires form: reference, form: scheduled requires a schedule e schedule requires form: scheduled.
Um emparelhamento vale num único sentido. Uma carga de trabalho form: stateful sem template de claim por réplica é comum e não provoca nada — a regra é que um template de claim precisa da identidade estável por réplica que só essa forma fornece, e não que a forma precise de um template de claim. Os outros dois emparelhamentos valem nos dois sentidos, porque um endpoint e um agendamento têm cada um exatamente uma forma em que significam alguma coisa.
Os dois emparelhamentos de endpoint estão também no esquema de Workload, pelo que uma carga de trabalho que viole qualquer um deles é recusada na fase de esquema, sob E0214, antes de a sua frase acima ser alcançada. Um endpoint: em qualquer forma que não seja reference — incluindo uma form: omitida, já que é lida como stateless — é recusado como
workload validation failed (Workload in Recipe <name>:<version>, at <path>, schema stage): .endpoint: value matches a shape that is not allowed here (a validação da carga de trabalho falhou, no Workload da Recipe e no caminho indicados, fase de esquema: .endpoint: o valor corresponde a uma forma que não é permitida aqui)
e form: reference sem endpoint: termina antes com .endpoint: missing required property: endpoint. A solução é a que a frase do emparelhamento indica.
Como corrigir: cada frase nomeia os dois campos e dá as duas respostas. Adicionar o campo de que a forma precisa, ou mudar a forma para aquela a que o campo pertence, ou remover o campo onde ficou para trás após uma edição — apagar um valor de schedule: e deixar a chave é a forma que este erro mais assume.
A workload schedule: is not an expression the check accepts (O agendamento de uma carga de trabalho não é uma expressão que a verificação aceite)
Uma carga de trabalho form: scheduled contém um schedule: que diz quando é executada, e a estrutura do valor é verificada antes de qualquer destino o ler. São aceites duas grafias: uma das cinco macros @hourly, @daily, @weekly, @monthly e @yearly, ou uma expressão crontab de cinco campos cujos campos usam apenas dígitos e os carateres *, ,, - e /.
O que a verificação lê e o que não lê. Conta os campos e examina os carateres neles. Não avalia intervalos, aritmética de passos nem nomes de dias da semana, pelo que uma expressão de cinco campos cujos números estejam fora do intervalo passa aqui e cabe ao destino rejeitá-la. Uma expressão de seis campos que contenha um campo inicial de segundos é recusada: cinco campos é o que esta superfície aceita, e um destino que queira segundos recebe-os de outra forma.
Mensagem emitida:
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 (o agendamento da carga de trabalho não é uma expressão cron válida; utilizar uma expressão crontab de 5 campos, como a do exemplo, ou uma de @hourly, @daily, @weekly, @monthly, @yearly)
A condição sob a qual é registada é schedule is not a valid cron expression, que é aquilo em que o seu código curto se resolve.
Como corrigir: contar primeiro os campos — um agendamento com quatro ou seis campos é a causa mais comum, e um espaço a mais dentro de um campo divide-o em dois. Substituir um dia ou um mês designado pelo nome pelo seu número, e recorrer a uma macro onde alguma diga o que se pretendia.
A workload suspend: is set on a form other than scheduled (A suspensão de uma carga de trabalho está definida numa forma diferente da agendada)
suspend: true retém o agendamento recorrente de uma carga de trabalho form: scheduled: o recurso agendado é renderizado, e nenhuma execução começa a partir do seu agendamento até ser retomado. Nenhuma outra forma contém um agendamento, pelo que em qualquer outra forma não há nada que o campo possa reter, e a compilação é interrompida em vez de renderizar uma carga de trabalho que o descarta silenciosamente. A verificação é executada juntamente com os outros emparelhamentos de forma, antes de qualquer destino traduzir a carga de trabalho, e também aqui uma form: omitida é lida como stateless.
Mensagem emitida:
workload declares suspend but is not form: scheduled; declare form: scheduled with a schedule or remove suspend (a carga de trabalho declara suspend, mas não é form: scheduled; declarar form: scheduled com um agendamento ou remover suspend)
É posicionada na instância do componente cuja carga de trabalho estava a ser lida, e comunicada como uma falha de tradução. A condição sob a qual é registada é suspend requires form: scheduled, que é aquilo em que o seu código curto se resolve.
A regra vale num único sentido, e apenas com true. Uma carga de trabalho form: scheduled sem suspend: é comum e é executada segundo o seu agendamento, e suspend: false, o valor predefinido, não provoca nada em nenhuma forma.
Como corrigir: onde a carga de trabalho devia ser executada apenas quando alguém a inicia, torná-la uma carga de trabalho form: scheduled com um schedule: e manter suspend: true; caso contrário, manter a forma como está escrita e remover suspend:, que nenhuma outra forma lê.
A library $import: is not written in the bare-name form (Uma importação de biblioteca não está escrita na forma de nome simples)
Três campos de uma Recipe e de uma FeatureRecipe podem obter o seu corpo de uma biblioteca em vez de o escrever no próprio local: uma entrada artifacts.<name>:, um valuesMapping: e um workload:. Cada um escreve $import: com o nome simples da biblioteca, depois #, depois o caminho da entrada na superfície que esse campo lê — #/artifacts/, #/mappings/ e #/workloads/, respetivamente. Um valor que não tenha essa forma não nomeia nada que a compilação possa resolver, e é recusado quando o campo é resolvido.
Os três campos são espelhos deliberados uns dos outros, pelo que a falha se lê da mesma forma nos três e só a superfície muda:
artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): "<the value as written>" (a importação de artifacts não é uma referência de nome simples a uma biblioteca de artefactos: com o valor indicado, tal como foi escrito) valuesMapping $import: is not a bare-name mapping-library reference (#/mappings/): "<the value as written>" (a importação de valuesMapping não é uma referência de nome simples a uma biblioteca de mappings: com o valor indicado, tal como foi escrito) workload $import: is not a bare-name workload-library reference (#/workloads/): "<the value as written>" (a importação de workload não é uma referência de nome simples a uma biblioteca de cargas de trabalho: com o valor indicado, tal como foi escrito)
Uma versão escrita com @ é comunicada com a grafia a utilizar em alternativa, em vez de resultar numa queixa de que a biblioteca não foi encontrada, porque é o erro que esta forma mais atrai:
artifacts $import: is not a bare-name artifact-library reference (#/artifacts/): version separator is ’:’, not ’@’ — use "<the corrected value>" (a importação de artifacts não é uma referência de nome simples a uma biblioteca de artefactos: o separador de versão é ’:’, não ’@’ — utilizar o valor corrigido indicado)
Mais uma forma é comunicada aqui, e não é um erro de grafia. O corpo próprio de um ficheiro de um bundle de uma ArtifactLibrary não pode ser ele próprio um $import: de outro bundle: uma posição de ficheiro não pode expandir-se em muitos ficheiros, pelo que uma importação aninhada é recusada em vez de ser resolvida em algo que o autor não escreveu. Em alternativa, compor os bundles no ponto em que são consumidos.
Uma entrada artifacts: que a Recipe própria de um componente escreve é decidida antes de qualquer renderização, pelo que a comunicação é posicionada no bloco artifacts: dessa Recipe e nomeia a referência, o bundle, o ficheiro cujo corpo contém a importação aninhada e a entrada em que a importação foi escrita. Cada ficheiro do bundle nessa forma é comunicado numa única compilação; onde há mais de um, as constatações são agrupadas sob 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 (a importação de artifacts não é uma referência de nome simples a uma biblioteca de artefactos, com o valor tal como foi escrito, o bundle, o ficheiro do bundle e a entrada de artifacts indicados. O corpo de um ficheiro de bundle não pode importar outro bundle — compor os dois na entrada de artifacts que os consome)
Uma entrada artifacts: que uma FeatureRecipe escreve comunica a mesma condição quando o bundle é resolvido, nomeando o primeiro ficheiro nessa 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) (a importação de artifacts não é uma referência de nome simples a uma biblioteca de artefactos: o corpo do ficheiro indicado do bundle indicado é uma importação na raiz do campo; uma importação de biblioteca aninhada dentro de um ficheiro de bundle não é suportada; compor no ponto de consumo)
Um valuesMapping: que a Recipe própria de um componente escreve é decidido antes de qualquer renderização, pelo que a comunicação é posicionada na chave valuesMapping: dessa Recipe e traz a grafia a utilizar:
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/ (a importação de valuesMapping não é uma referência de nome simples a uma biblioteca de mappings, com o valor indicado, tal como foi escrito. Nomear a biblioteca e a entrada de cada lado do fragmento — escrever a forma indicada)
Um valuesMapping: que uma FeatureRecipe escreve é comunicado quando a referência é resolvida, na forma que a lista acima traz.
Um workload: que a Recipe própria de um componente escreve é decidido antes de qualquer renderização, pelo que a comunicação é posicionada na chave workload: dessa Recipe e traz a grafia a utilizar:
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/ (a importação de workload não é uma referência de nome simples a uma biblioteca de cargas de trabalho, com o valor indicado, tal como foi escrito. Nomear a biblioteca e a entrada de cada lado do fragmento — escrever a forma indicada)
Um workload: que uma FeatureRecipe escreve é comunicado quando a referência é resolvida, na forma que a lista acima traz.
Como corrigir: reescrever o valor como <Library>#<entry-path>, acrescentando :<version> após o nome da biblioteca apenas onde for necessário um mínimo para a versão que pode ser selecionada. Verificar se o fragmento corresponde ao campo — um caminho de entrada #/mappings/… num workload: nomeia uma superfície que esse campo não lê, e é comunicado aqui, e não como uma entrada em falta. A mesma forma de identidade rege o $ref: de um esquema, cujas recusas estão documentadas em «A $ref: is not written in a form the compiler can resolve (Uma referência não está escrita numa forma que o compilador consiga resolver)» acima.
A library $import: names a library or an entry the catalog does not hold (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
Um $import: está escrito corretamente e aquilo para que aponta não está lá. Seis condições cobrem as duas metades de uma referência nos três tipos de biblioteca, e a que surge indica que metade examinar: a própria biblioteca está ausente daquilo que a compilação consegue ver, ou a biblioteca está lá e não publica a entrada.
O conjunto face ao qual uma referência se resolve é o catálogo próprio do espaço de trabalho mais as bibliotecas que o lockfile fixou e trouxe enquanto a compilação era carregada. Assim, uma biblioteca da qual nada no fecho de dependências da Release declara depender não está nesse conjunto, por mais correta que pareça a referência a ela.
A biblioteca não está lá:
artifact-library import references an ArtifactLibrary not present in the catalog: ArtifactLibrary "<library>" (bundle "<entry>") (uma importação de biblioteca de artefactos referencia uma ArtifactLibrary que não está presente no catálogo: com a ArtifactLibrary e o bundle indicados) mapping-library import references a MappingLibrary not present in the catalog: MappingLibrary "<library>" (entry "<entry>") (uma importação de biblioteca de mappings referencia uma MappingLibrary que não está presente no catálogo: com a MappingLibrary e a entrada indicadas) workload-library import references a WorkloadLibrary not present in the catalog: WorkloadLibrary "<library>" (entry "<entry>") (uma importação de biblioteca de cargas de trabalho referencia uma WorkloadLibrary que não está presente no catálogo: com a WorkloadLibrary e a entrada indicadas)
A entrada não está lá:
artifact-library import references a bundle not present in the ArtifactLibrary: bundle "<entry>" in ArtifactLibrary "<library>" (uma importação de biblioteca de artefactos referencia um bundle que não está presente na ArtifactLibrary: com o bundle e a ArtifactLibrary indicados) mapping-library import references an entry not present in the MappingLibrary: entry "<entry>" in MappingLibrary "<library>" (uma importação de biblioteca de mappings referencia uma entrada que não está presente na MappingLibrary: com a entrada e a MappingLibrary indicadas) workload-library import references an entry not present in the WorkloadLibrary: entry "<entry>" in WorkloadLibrary "<library>" (uma importação de biblioteca de cargas de trabalho referencia uma entrada que não está presente na WorkloadLibrary: com a entrada e a WorkloadLibrary indicadas)
Uma entrada artifacts: que a Recipe própria de um componente escreve comunica um bundle em falta numa forma própria. Essa entrada é decidida antes de qualquer coisa ser renderizada, pelo que a comunicação é posicionada no bloco artifacts: dessa Recipe e nomeia a entrada em que a importação foi escrita juntamente com as duas metades da referência:
artifact-library import references a bundle not present in the ArtifactLibrary ("<entry>", ArtifactLibrary "<library>", artifacts entry "<key>") (uma importação de biblioteca de artefactos referencia um bundle que não está presente na ArtifactLibrary: com o bundle, a ArtifactLibrary e a entrada de artifacts indicados)
Um valuesMapping: que a Recipe própria de um componente escreve comunica uma entrada em falta numa forma própria, pelo mesmo motivo: também é decidido antes de qualquer coisa ser renderizada, pelo que a comunicação é posicionada na chave valuesMapping: dessa Recipe e nomeia as duas metades da referência:
mapping-library import references an entry not present in the MappingLibrary ("<entry>", MappingLibrary "<library>") (uma importação de biblioteca de mappings referencia uma entrada que não está presente na MappingLibrary: com a entrada e a MappingLibrary indicadas)
Um workload: que a Recipe própria de um componente escreve comunica uma entrada em falta numa forma própria, pelo mesmo motivo: também é decidido antes de qualquer coisa ser renderizada, pelo que a comunicação é posicionada na chave workload: dessa Recipe e nomeia as duas metades da referência:
workload-library import references an entry not present in the WorkloadLibrary ("<entry>", WorkloadLibrary "<library>") (uma importação de biblioteca de cargas de trabalho referencia uma entrada que não está presente na WorkloadLibrary: com a entrada e a WorkloadLibrary indicadas)
Uma entrada artifacts: que uma FeatureRecipe escreve, um valuesMapping: ou um workload: que uma FeatureRecipe escreve, e qualquer referência a uma biblioteca que a compilação não consegue ver, são comunicados à medida que a referência é resolvida, nas formas que as duas listas acima apresentam.
Cada uma nomeia tanto a biblioteca como a entrada, seja qual for a metade que falhou, pelo que uma única comunicação basta para distinguir uma biblioteca em falta de uma entrada em falta sem abrir nada.
Como corrigir: para uma entrada em falta, verificar o nome face àquilo que a biblioteca publica — o nome de uma entrada é uma chave no mapa próprio dessa biblioteca, e distingue maiúsculas de minúsculas. Para uma biblioteca em falta, a referência está normalmente certa e o que fica aquém é o fecho: declarar a dependência dessa biblioteca para que seja carregada, e atualizar o lockfile para que seja fixada. Uma biblioteca alcançável num espaço de trabalho e não noutro é a mesma falha vista do outro lado.
A library $import: addresses its library by registry location (Uma importação de biblioteca endereça a sua biblioteca pela localização no registo)
Um $import: de biblioteca nomeia a sua biblioteca pela identidade, nunca pelo registo em que por acaso está publicada. O registo através do qual um nome se resolve é configuração do espaço de trabalho, e a versão usada é a resposta do lockfile, pelo que uma referência que contenha um host fixa num documento de catálogo duas coisas que cabe à compilação decidir — e o documento deixa então de funcionar em qualquer espaço de trabalho configurado de outra forma.
Os casos em que tal referência ainda pode chegar a esta interrupção são mais restritos do que parece. Os campos $import: próprios de uma Recipe e de uma FeatureRecipe são recusados mais cedo, pelo seu esquema, que não admite nenhum prefixo de registo em nenhuma das três posições. O que resta é a referência que nenhum esquema descreve: uma lida do próprio corpo de uma entrada de biblioteca, que a entidade que a consome não escreveu e não consegue ver até o corpo ser resolvido.
Mensagem emitida, a partir das superfícies valuesMapping: e workload:, onde o resolvedor comunica apenas o valor:
library $import: carries a registry host; reference the library by bare-name identity: "<the value as written>" (a importação de biblioteca contém um host de registo; referencie a biblioteca pela identidade de nome simples: com o valor indicado, tal como foi escrito)
Uma entrada artifacts: não chega a esta interrupção, e vale a pena saber porquê, se for aí que a procura. A sua própria referência é recusada com o resto do documento, como qualquer outra posição; e, ao contrário das outras duas superfícies, um ficheiro de bundle cujo corpo é ele próprio uma importação é rejeitado em vez de seguido — pelo que não existe nenhum corpo de onde pudesse vir uma referência com host.
Como corrigir: remover o host e tudo o que antecede o nome da biblioteca, deixando <Library>#<entry-path>. Onde o valor problemático está dentro de uma biblioteca que se consome, e não numa que se publica, a correção cabe ao autor dessa biblioteca; até que chegue, importar uma entrada diferente ou escrever o corpo no próprio local desbloqueia a compilação.
Two artifact outputs of one Recipe carry the same filename (Duas saídas de artefactos de uma mesma Recipe têm o mesmo nome de ficheiro)
O bloco artifacts: de uma Recipe nomeia uma saída por chave, e um bundle importado numa chave contribui com os seus ficheiros por baixo dela. Duas saídas que chegassem a um mesmo nome de ficheiro significariam que uma substitui a outra, pelo que a compilação é interrompida em vez de escolher qual sobrevive.
Esta é uma proteção residual, e dizê-lo faz parte do que ela é. Uma saída é nomeada pela chave sob a qual foi escrita, as chaves de um mapa são únicas dentro de um documento, e a superfície de autoria limita uma chave a um único nome de ficheiro — pelo que duas entradas escritas pelo autor não podem colidir, e uma chave também não pode escrever o nome aninhado que o bundle de outra chave produz. O que a proteção ainda cobre é conteúdo que chegou à projeção sem passar pela recusa de chaves duplicadas própria de um documento escrito pelo autor: estado montado durante a execução da compilação em vez de lido de um ficheiro. Uma colisão comunicada aqui aponta, portanto, para a forma como a compilação foi montada, e não para uma linha que se consiga ver.
É levantada por Recipe, sobre as saídas próprias dessa Recipe, e é isso que a separa de dois contribuidores diferentes que acabam num mesmo caminho numa montagem — isso é «Two contributors write the same output path (Dois contribuidores escrevem o mesmo caminho de saída)» acima, com um remédio diferente.
Mensagem emitida:
artifacts output filename collision: two artifact outputs carry the same filename (Recipe "<recipe>", artifact output "<filename>" emitted more than once) (colisão de nome de ficheiro de uma saída de artifacts: duas saídas de artefactos têm o mesmo nome de ficheiro, com a Recipe e a saída de artefacto indicadas, emitida mais de uma vez)
Como corrigir: abrir a Recipe que a mensagem nomeia e verificar as suas chaves artifacts: face aos ficheiros com que contribui qualquer bundle que importe. Onde as chaves são de facto distintas e a colisão se mantém, nada no documento está errado, e vale a pena levar a comunicação a quem mantém a compilação.
An ArtifactLibrary bundle file names no file of its own under the key it was imported at (Um ficheiro de bundle de uma ArtifactLibrary não nomeia nenhum ficheiro próprio sob a chave em que foi importado)
Uma entrada artifacts: que importa um bundle expande-se numa saída por cada ficheiro desse bundle, cada uma aninhada sob a chave em que a importação foi escrita. Assim, a chave nomeia um diretório e cada ficheiro com que o bundle contribui pertence por baixo dele, sob um nome próprio. Um nome de ficheiro que sobe para fora desse diretório, nomeia uma localização absoluta ou não nomeia absolutamente nada não pertence, e a compilação é interrompida em vez de colocar o ficheiro num local que a Recipe consumidora nunca escolheu.
Não nomear nada abrange todos os nomes que não sejam a única grafia de um único ficheiro por baixo da chave.. e ./, e um nome que volta a cair sobre a chave, como x/.., nomeiam a própria chave, pelo que o ficheiro seria escrito onde deve estar o diretório da chave. Um nome com uma / final ou duplicada, ou com uma parte . ou .. — x/, a//b, ./a, a/./b, a/../b — é uma segunda grafia de um ficheiro que outro nome pode ter: a//b ao lado de a/b são dois nomes para um mesmo ficheiro, e um seria escrito por cima do outro sem que fosse comunicada qualquer colisão. O nome vazio também é recusado.
O que impede é uma reorganização silenciosa, e não uma escrita fora do diretório de saída. O local onde os ficheiros são escritos é protegido de novo, pelo que um nome que suba o suficiente é aí recusado de qualquer forma. O nome que passa essa proteção é o que sobe exatamente um nível: volta a cair dentro do diretório de saída, numa posição que ninguém escolheu. Isso é pior do que uma escrita recusada, porque todas as proteções contra colisões neste caminho leem um nome tal como foi composto e não tal como se resolve — pelo que dois ficheiros destes podem resolver-se numa mesma saída sem que nada comunique uma colisão, e qual deles sobrevive é decidido por nada que alguém tenha escrito.
Uma estrutura aninhada escrita de forma simples dentro da chave não é afetada. Um bundle é livre de trazer os seus próprios subdiretórios, como rbac/role.yaml, e aninhá-los sob a chave de consumo é precisamente aquilo para que a chave serve. Um nome que apenas contém pontos dentro de uma parte, como ..config ou role.v1.yaml, é um nome comum.
A Recipe consumidora e o bundle publicado são normalmente escritos por autores diferentes, pelo que a mensagem nomeia as duas metades juntamente com o remédio.
Uma entrada artifacts: que a Recipe própria de um componente escreve é decidida antes de qualquer coisa ser renderizada, pelo que a comunicação é posicionada no bloco artifacts: dessa Recipe e nomeia primeiro o ficheiro, depois a biblioteca de onde veio e a entrada em que é consumido. Cada ficheiro do bundle cujo nome é recusado é comunicado numa única compilação; onde há mais do que um, as constatações são agrupadas sob 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 ”/” (o nome de um ficheiro do bundle de uma biblioteca de artefactos não nomeia um ficheiro próprio por baixo da chave de artifacts sob a qual a sua saída está aninhada, com o ficheiro, a ArtifactLibrary e a entrada de artifacts indicados. mudar o nome do ficheiro dentro do bundle da ArtifactLibrary para um nome de ficheiro comum por baixo da chave de artifacts em que é consumido, como «config.yaml» ou «rbac/role.yaml» — nenhuma parte «.» ou «..», e nenhuma «/» inicial, final ou duplicada)
Uma entrada artifacts: que uma FeatureRecipe escreve comunica a mesma condição à medida que o bundle é resolvido, nomeando a receita em que foi escrita e o primeiro desses ficheiros:
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 ”/” (o nome de um ficheiro do bundle de uma biblioteca de artefactos não nomeia um ficheiro próprio por baixo da chave de artifacts sob a qual a sua saída está aninhada, com a Recipe, o artefacto e o ficheiro de bundle indicados. mudar o nome do ficheiro dentro do bundle da ArtifactLibrary para um nome de ficheiro comum por baixo da chave de artifacts em que é consumido, como «config.yaml» ou «rbac/role.yaml» — nenhuma parte «.» ou «..», e nenhuma «/» inicial, final ou duplicada)
Como corrigir: mudar o nome do ficheiro dentro da ArtifactLibrary para um nome de ficheiro comum por baixo da chave. Onde a biblioteca não é própria, importar um bundle diferente ou escrever a entrada no próprio local desbloqueia a compilação enquanto a correção é feita a montante. Um ficheiro destinado a acabar num local completamente diferente é uma segunda entrada artifacts: na chave a que pertence, e não um nome que sobe até lá.
An imported artifact no longer matches the digest recorded beside its Recipe (Um artefacto importado já não corresponde ao digest registado ao lado da sua Recipe)
Uma entrada artifacts: que importa um ficheiro local tem o seu conteúdo fixado quando a Recipe é fixada — por aggrega pin, ou por um pull ou um push a que se pede que execute o mesmo passo: o digest dos bytes do ficheiro é registado em entity.lock, ao lado da Recipe. Uma entrada do boundary.artifacts: de uma Recipe é fixada e comparada da mesma forma, e registada sob boundary/<key>, que é o nome que a mensagem lhe dá. Cada compilação volta a ler o ficheiro, volta a calcular o seu digest e recusa a discrepância — assim, um ficheiro editado depois de ter sido fixado nunca é renderizado como se tivesse sido verificado. aggrega pull --verify faz a mesma comparação e comunica uma discrepância com a mesma mensagem.
O que é comparado é o conteúdo da entrada, e não aquilo que a sua renderização produziu. O corpo de um artefacto é um template, e avaliá-lo substitui valores que diferem por instância de componente, pelo que um digest sobre a saída divergiria para cada instância cujos valores difiram. O conteúdo registado é o mesmo texto para cada instância que se liga à Recipe, e é isso que torna um único digest registado a referência certa para comparar.
Três superfícies trazem a mesma verificação sobre documentos diferentes — a Recipe própria de um componente, uma Feature anexada a um componente e uma Feature anexada a uma fronteira —, pelo que o conteúdo da FeatureRecipe é medido face ao digest registado ao lado da FeatureRecipe, e não ao lado da Recipe do componente anfitrião. Nas duas superfícies de anexo, a mensagem nomeia também o anexo, e é isso que indica que documento abrir.
Mensagens emitidas:
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 (o conteúdo do artefacto importado não corresponde ao digest registado para ele em entity.lock, com o artefacto, o ficheiro importado, o digest do seu conteúdo e a fixação registada indicados. Se o ficheiro foi alterado de propósito, executar aggrega pin na entidade que o importa para registar o seu novo digest; caso contrário, restaurar o ficheiro) 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 (o conteúdo do artefacto importado não corresponde ao digest registado para ele em entity.lock, com o artefacto, o ficheiro importado, o digest do seu conteúdo, a fixação registada e o anexo indicados. Se o ficheiro foi alterado de propósito, executar aggrega pin na entidade que o importa para registar o seu novo digest; caso contrário, restaurar o ficheiro)
Como corrigir: duas respostas, e qual é a certa depende de a edição ter sido intencional. Se foi, executar aggrega pin na Recipe para que a fixação seja feita de novo a partir dos bytes atuais do ficheiro, e fazer commit do entity.lock que ele reescreve. Se não foi, restaurar o ficheiro — o digest registado é o registo dos bytes que foram fixados, e uma compilação que renderizasse o ficheiro alterado estaria a entregar conteúdo que nada verificou.
A local source no longer matches the pins recorded beside its Recipe (Uma origem local já não corresponde às fixações registadas ao lado da sua Recipe)
Uma Recipe ou FeatureRecipe cujo source: nomeia um diretório ou um ficheiro ao lado dela tem essa origem fixada quando a entidade é fixada — por aggrega pin, ou por um pull ou um push a que se pede que execute o mesmo passo. O entity.lock ao lado da entidade regista um digest por cada ficheiro com que a origem contribui para aquilo que uma publicação da entidade transporta, indexado pelo caminho do ficheiro. Assim que o lock os regista, cada compilação compara a origem tal como está com essas fixações antes de o fornecedor a ler, e recusa uma discrepância — assim, um chart ou um módulo editado depois de ter sido fixado nunca é renderizado como se tivesse sido verificado. aggrega pull --verify faz a mesma comparação e comunica uma discrepância com a mesma mensagem. Uma compilação nomeia a instância de componente cuja origem estava a resolver e, por baixo dela, o documento da Recipe.
A origem é comparada como um único conjunto de ficheiros. Um ficheiro cujo conteúdo mudou, um ficheiro acrescentado à origem e um ficheiro removido dela mudam, cada um, aquilo a partir do qual a entidade é renderizada, pelo que cada um é comunicado, com o digest que o ficheiro tem agora e o digest registado para ele. Um ficheiro ao lado da entidade com que a origem não contribui — uma nota ou um README junto à Recipe — não é comparado. Uma origem escrita como template, como ./charts/{{ .values.flavour }}, contribui com todos os ficheiros do diretório da entidade, porque o diretório que nomeia é decidido por cada Release; para essa forma, é comunicada uma edição de qualquer ficheiro do diretório.
Uma Recipe cujo lock não regista nenhuma fixação para a sua origem não tem nada que uma compilação possa comparar. Uma compilação não a recusa; um pull ou um push que não fixe recusa-a, como descreve An entity reads an input the lock beside it records no pin for (Uma entidade lê uma entrada para a qual o lock ao lado dela não regista nenhuma fixação). As fixações que um lock ainda regista para uma origem local que a Recipe já não declara não fixam nada do que ela lê, pelo que não são comparadas com nada. Uma Recipe que um pull resolveu a partir de um registo é coberta, em vez disso, pelo digest que o lockfile regista para aquilo que a sua publicação transporta.
Um lockfile escrito antes da alteração comunica primeiro. O lockfile regista a entidade por aquilo que transporta, e os ficheiros da origem fazem parte disso, pelo que uma compilação ou aggrega pull --verify com um lockfile escrito antes de um ficheiro mudar interrompe-se antes de esta comparação ser executada, com The lockfile no longer matches what the release resolves to (O ficheiro de bloqueio já não corresponde àquilo em que a Release se resolve) a nomear a entidade e ambos os digests. Um aggrega pull simples nomeia o ficheiro que mudou, com An entity reads an input the lock beside it records no pin for (Uma entidade lê uma entrada para a qual o lock ao lado dela não regista nenhuma fixação). O mesmo se aplica a um ficheiro importado. Onde o lockfile não tem nenhuma entrada própria da entidade, esta comparação é a que uma compilação e um pull de verificação encontram: uma Recipe ou FeatureRecipe que o Manifest nomeia através de uma referência que é também o nome de um Component ou de uma Feature que a Release alcança é registada sob essa referência como o Component ou a Feature, pelo que nada no lockfile muda quando os ficheiros da Recipe mudam.
Mensagens emitidas:
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 (os ficheiros da origem local da entidade não correspondem às fixações registadas para eles em entity.lock, com o ficheiro, o seu digest e a sua fixação registada indicados. Se a origem foi alterada de propósito, executar aggrega pin na entidade para registar os seus ficheiros de novo; caso contrário, restaurar os ficheiros) 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 (os ficheiros da origem local da entidade não correspondem às fixações registadas para eles em entity.lock, com o ficheiro e o seu digest indicados, para o qual não está registada nenhuma fixação. Se a origem foi alterada de propósito, executar aggrega pin na entidade para registar os seus ficheiros de novo; caso contrário, restaurar os ficheiros) 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 (os ficheiros da origem local da entidade não correspondem às fixações registadas para eles em entity.lock, com o ficheiro indicado, que já não está na origem, e a sua fixação registada. Se a origem foi alterada de propósito, executar aggrega pin na entidade para registar os seus ficheiros de novo; caso contrário, restaurar os ficheiros)
Como corrigir: tal como para um ficheiro importado, duas respostas, e qual é a certa depende de a alteração ter sido intencional. Se foi, executar aggrega pin na Recipe para que os ficheiros da sua origem sejam fixados de novo, e fazer commit do entity.lock que ele reescreve. Se não foi, restaurar os ficheiros que a mensagem nomeia.
A symbolic link sits among the files an entity carries (Uma ligação simbólica está entre os ficheiros que uma entidade transporta)
Cada ficheiro que uma publicação de uma entidade transporta é lido do diretório próprio da entidade, e uma ligação simbólica aí é recusada em vez de seguida. Segui-la publicaria os bytes para que aponta sob o próprio nome da ligação — de onde quer que aponte, incluindo fora do diretório da entidade — num artefacto cujo digest é então calculado e que, onde a assinatura se aplica, é assinado. Ignorá-la, em vez disso, publicaria um artefacto cujo conteúdo difere silenciosamente do seu diretório. Por isso, toda a forma de ligação é recusada da mesma maneira: uma ligação para um ficheiro, uma ligação para um diretório, uma ligação que não aponta para lado nenhum, uma ligação que aponta para si própria e duas ligações que apontam uma para a outra.
A recusa é feita onde quer que os ficheiros da entidade sejam lidos: por aggrega pin, por uma publicação antes de empacotar o que quer que seja (incluindo uma execução de teste), por um pull e um pull de verificação que confrontam o entity.lock com os ficheiros da entidade, por uma compilação que compara uma origem local com as suas fixações, e por uma renderização que lê um diretório de origem local antes de qualquer parte dele ser entregue a um fornecedor. A mensagem nomeia a ligação pelo seu caminho ao lado do documento da entidade, e o diagnóstico é posicionado na própria ligação.
Uma ligação que as regras de exclusão deixam de fora não é um ficheiro que a entidade transporta, pelo que é ignorada como qualquer outro ficheiro que essas regras deixam de fora, e nunca é seguida. Essas regras são as registadas no entity.lock quando a entidade foi fixada, pelo que uma linha acrescentada a .aggregaignore produz efeito quando a entidade é fixada de novo.
Mensagem emitida:
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 (uma ligação simbólica está entre os ficheiros que uma entidade transporta, com o caminho indicado. solução: substituir a ligação por uma cópia daquilo para que aponta, colocada dentro do diretório próprio da entidade. Uma ligação encontrada dentro de um diretório de origem pode, em vez disso, ser deixada de fora com uma linha no .aggregaignore ao lado da entidade, que produz efeito quando a entidade é fixada de novo. Uma ligação é recusada em vez de seguida porque os bytes para que aponta viajariam sob o nome da ligação, de onde quer que aponte)
Como corrigir: onde a entidade precisa daquilo para que a ligação aponta, substituir a ligação por uma cópia do seu destino dentro do diretório da entidade, e fixar a entidade de novo. Onde a ligação existe por mera conveniência e a entidade não a lê, acrescentar o seu caminho ao .aggregaignore ao lado do documento da entidade e fixar de novo. Que ficheiros são distribuídos com uma entidade descreve as regras que decidem aquilo que uma entidade transporta.
An entity reads an input the lock beside it records no pin for (Uma entidade lê uma entrada para a qual o lock ao lado dela não regista nenhuma fixação)
Uma Recipe ou FeatureRecipe pode depender de bytes fora do seu próprio documento: um source: remoto cujas coordenadas estão escritas por extenso, um ficheiro que uma entrada artifacts importa com $import, e os ficheiros de um source: que nomeia um diretório ou um ficheiro ao lado dela. A fixação de cada um é registada no entity.lock ao lado da entidade, e registá-la é o passo do autor da entidade, aggrega pin. Por isso, um pull não regista essas fixações por iniciativa própria: sobre uma entidade num dos seus diretórios de catálogo que a Release compila, compara aquilo que o passo registaria com aquilo que o lock contém, e interrompe-se quando falta uma fixação no lock — ou quando este contém uma a que a entrada já não corresponde — em vez de escrever no diretório do autor sem que isso seja pedido. Uma compilação que preenche o seu próprio lockfile é um pull e interrompe-se da mesma forma.
Um push interrompe-se na mesma comparação, sobre a única entidade que está prestes a publicar. Antes de o bundle ser construído, e antes de qualquer registo ser contactado, compara aquilo que o passo registaria para a entidade com o lock ao lado dela, e recusa da mesma forma — incluindo uma execução de teste — a menos que se tenha pedido ao push que executasse ele próprio o passo. Aquilo que a mensagem sugere no fim difere entre os dois, porque cada comando tem as suas próprias formas de fazer registar as fixações; aquilo que comunica, não.
Uma origem local é confrontada com as suas fixações como um único conjunto de ficheiros. Onde o lock não regista nenhuma delas, cada ficheiro com que a origem contribui é comunicado aqui como em falta. Onde as regista, um ficheiro acrescentado desde a fixação é comunicado como em falta e um ficheiro alterado ou removido como uma fixação a que a entrada já não corresponde, e uma compilação comunica a mesma alteração como A local source no longer matches the pins recorded beside its Recipe (Uma origem local já não corresponde às fixações registadas ao lado da sua Recipe). As fixações que um lock ainda regista para uma origem local que a Recipe já não declara — com o seu source: removido, ou agora a nomear um artefacto remoto — não fixam nada do que a Recipe lê, pelo que não interrompem nem um pull, nem um push, nem um pull de verificação, nem uma compilação; o próximo aggrega pin descarta-as.
A mensagem nomeia cada entrada em falta, por classe. Cada uma é uma remote source, nomeada pelo seu url e pela versão em que se resolveu, um imported file, nomeado pela chave artifacts que o consome, ou um local source file, nomeado pelo seu caminho ao lado da entidade — assim, fica a saber-se se é uma origem ou um ficheiro que precisa de ser fixado. Cada entidade deste tipo na Release é comunicada numa única execução.
Uma entidade resolvida a partir de um registo nunca é confrontada com isto por um pull, porque a sua publicação já o foi. Encontra-se na cache de conteúdo e não num diretório de que o utilizador seja autor, pelo que um pull não lê nem escreve nenhum lock ao lado dela, e as suas origens são confrontadas com o lockfile da Release. Uma entidade publicada com aggrega push foi recusada na publicação, a menos que o seu lock registasse cada fixação que o passo registaria para ela nesse momento, e esse lock viaja dentro do bundle publicado.
Mensagens emitidas, por um pull e por um 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 (uma entrada que a entidade lê não tem nenhuma fixação registada para ela no entity.lock ao lado dela, com a Recipe indicada, uma origem remota indicada com a sua versão para a qual não está registada nenhuma fixação, e um ficheiro importado indicado a que a fixação registada já não corresponde. solução: executar aggrega pin no caminho da entidade indicado e fazer commit do entity.lock que ele escreve ao lado da entidade; para que, em vez disso, cada pull neste espaço de trabalho registe as fixações por si próprio, definir pin_sources_at_pull: true na configuração do espaço de trabalho) 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 (uma entrada que a entidade lê não tem nenhuma fixação registada para ela no entity.lock ao lado dela, com a Recipe indicada e uma origem remota indicada com a sua versão para a qual não está registada nenhuma fixação. solução: executar aggrega pin no caminho da entidade indicado e fazer commit do entity.lock que ele escreve ao lado da entidade; para que, em vez disso, esta publicação registe as fixações por si própria, executá-la de novo com —pin-sources; para que cada publicação neste espaço de trabalho as registe, definir pin_sources_at_push: true na configuração do espaço de trabalho)
A oração central da mensagem da publicação nomeia aquilo que a superfície a partir da qual se publicou aceita: --pin-sources num terminal, o campo pinSources no daemon e o argumento pin_sources da ferramenta do assistente.
Como corrigir: onde a entidade é própria, executar aggrega pin sobre ela e fazer commit do entity.lock que ele escreve, e depois fazer o pull ou o push de novo — ou fazer o push com --pin-sources, que executa o passo antes de o bundle ser construído. Onde pertence a outra pessoa — um catálogo consumido a partir de um diretório próprio —, quem a publica ainda não a fixou; definir pin_sources_at_pull: true na configuração do espaço de trabalho para que cada pull registe as fixações por si próprio, ou passar --pin-sources a um único pull. aggrega pin descreve o passo por completo.
A provides: template could not be evaluated (Não é possível avaliar um template de provides)
Uma entrada provides: é um template que produz o valor que outro componente lê através de uma conexão de dependência. Esta condição é aquilo que comunica uma entrada que não pôde ser avaliada: um template que não pode ser analisado, uma função que chama e que esta superfície não regista, uma referência que desce através de algo que o contexto de renderização não forneceu, ou uma leitura com index de uma chave que o mapa não contém.
É distinta das duas recusas que são executadas antes da avaliação no mesmo bloco — uma referência a uma raiz fora do conjunto autocontido e uma referência que a própria ordem de autoria do bloco recusa —, ambas documentadas acima. Essas nomeiam a expressão a alterar; esta transporta aquilo que a própria avaliação tiver comunicado, e é por isso que a entrada é nomeada ao lado.
Mensagem emitida, que nomeia a instância de componente, a entrada dentro do bloco e aquilo que a avaliação comunicou:
provides template evaluation failed (node "<instance>", provides["<key>"], <what the evaluation reported>) (a avaliação do template de provides falhou, com o nó, a chave de provides e aquilo que a avaliação comunicou indicados)
O cabeçalho transporta o código desta condição, E0056, seja o que for que a avaliação tenha comunicado. Onde a avaliação parou numa condição de interrupção própria — uma leitura com index de uma chave que o mapa não contém é a habitual —, essa condição é comunicada por baixo desta em vez de no seu lugar: sob caused by (2):, a frase desta condição vem primeiro e a comunicação própria da avaliação em segundo lugar, incluindo a sua frase. Assim, quem faz corresponder códigos associa cada entrada provides: que falhou a E0056, e lê aquilo que fez a avaliação falhar na condição por baixo, cuja frase remete para o seu próprio código na tabela de todas as condições — E0327 para a chave ausente.
Como corrigir: abrir o bloco provides: da Recipe na chave que a mensagem nomeia e ler o motivo comunicado — normalmente nomeia uma posição de análise ou uma função. O tratamento de chaves em falta nesta superfície renderiza uma chave final ausente como nada em vez de falhar, pelo que uma falha aqui é um defeito estrutural: um template que não pode ser analisado, uma referência que desce através de um contentor que nunca foi fornecido, ou uma leitura com index de uma chave que o mapa não contém, que o motivo comunicado nomeia. Onde o valor é realmente opcional, lê-lo através do helper optional em vez de descer em algo que pode não estar lá.
A Recipe or FeatureRecipe does not publish a provides key its contract declares (Uma Recipe ou FeatureRecipe não publica uma chave provides que o seu contrato declara)
Um Component e uma Feature declaram cada um, sob schema.provides, as chaves que qualquer coisa associada a eles irá publicar — o contrato de saída face ao qual um consumidor escreve as suas ligações. A Recipe associada a um Component e a FeatureRecipe associada a uma Feature têm de produzir cada chave que esse contrato nomeia. Uma que não o faça é recusada, porque, de outro modo, a chave em falta não entregaria absolutamente nada: a referência do consumidor chegaria como uma variável não definida, um argumento vazio ou um ficheiro que não existe, sem que nada dissesse porquê.
O contrato é a presença das chaves, e nada mais. Cada chave declarada tem de aparecer; são permitidas chaves adicionais. Os próprios valores nunca são inspecionados — são ponteiros opacos encaminhados como cadeias, pelo que os tipos que um contrato declara continuam a ser uma indicação para o consumidor, e não uma verificação que a compilação faz.
Cada falta é comunicada. Uma Recipe à qual faltam três chaves gera três constatações, cada uma posicionada na sua própria entrada do bloco provides: dessa Recipe, pelo que as três são corrigidas a partir de uma única compilação. A mensagem nomeia a chave em falta, o tipo cujo contrato a declara e a instância à qual a Recipe estava associada — esta última é o que distingue duas constatações quando uma Recipe serve várias instâncias de um mesmo tipo.
Mensagem emitida:
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>") (a Recipe ou FeatureRecipe não publica uma chave provides que o contrato schema.provides da sua entidade abstrata declara (com a chave indicada, declarada pelo tipo de componente indicado, associada à instância de componente indicada))
O emparelhamento entre Feature e FeatureRecipe comunica a mesma condição através da resolução própria do anexo, nomeando o par e a chave:
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) (a Recipe ou FeatureRecipe não publica uma chave provides que o contrato schema.provides da sua entidade abstrata declara (com o contexto de anexo indicado: a FeatureRecipe indicada não publica a chave provides indicada, declarada pelo contrato schema.provides da Feature indicada))
Aí comunica a primeira chave em falta por ordem alfabética e para, pelo que esse emparelhamento nomeia uma chave por compilação, enquanto o emparelhamento do Component as nomeia todas. As chaves são percorridas por ordem alfabética em ambos os casos, e é isso que torna ambos iguais de uma execução para a outra.
Como corrigir: acrescentar a chave em falta ao bloco provides: da Recipe ou FeatureRecipe, ou removê-la do schema.provides do Component ou da Feature onde não se espera que nada a publique. Uma chave cujo template é renderizado como nada é ainda assim publicada, com a cadeia vazia como valor, pelo que uma entrada presente e vazia cumpre o contrato e não é comunicada aqui. Onde um valor vazio tem de parar a compilação, recusá-lo numa asserção: as asserções de uma Recipe leem os seus valores provides: resolvidos.
An assertion stopped the build (Uma asserção parou a compilação)
Um Component, uma Feature, uma Recipe ou uma FeatureRecipe pode trazer assertions: — templates com nome cujo propósito é recusar uma entrada em vez de produzir texto. Uma asserção chama fail, e é essa chamada que para a compilação; o argumento é a mensagem que o seu autor escreveu para quem a encontrar.
As asserções são avaliadas em dois momentos, para que uma regra leia o estado a que diz respeito: as de um Component ou de uma Feature são executadas depois de o catálogo estar resolvido e antes de qualquer coisa ser renderizada, e as de uma Recipe ou de uma FeatureRecipe são executadas depois de a associação estar estabelecida e antes de essa associação ser renderizada.
Uma referência a uma chave que nada fornece também é comunicada aqui. A superfície avalia com um tratamento estrito de chaves em falta, precisamente para que um predicado cuja referência foi renderizada como vazia não possa ser comparado com nada e passar silenciosamente — de outro modo, um único erro de escrita deixaria sem efeito a regra que a asserção foi escrita para fazer cumprir. É por isso que um default simples não fornece um fallback nesta superfície: a referência nua para a avaliação antes de o fallback poder ser executado. A referência deve ser condicionada com hasKey, ou deve usar-se o helper optional; lê-la através de index também provoca uma interrupção, nomeando a chave, como descreve «A template indexes a map with a key the map does not hold (Um template indexa um mapa com uma chave que o mapa não contém)».
Mensagem emitida, que nomeia a classe de entidade e o tipo, a instância e a asserção, e depois traz a mensagem que a própria asserção escreveu:
<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> (asserção indicada da instância indicada, do tipo e da classe de entidade indicados: asserção indicada: template: na linha e na coluna indicadas: execução da asserção indicada na expressão fail indicada: erro ao chamar fail: a asserção falhou: com a mensagem que a asserção escreveu)
e, para uma chave que nada fornece, a frase do motor de templates depois da frase própria da condição:
<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>" (asserção indicada da instância indicada, do tipo e da classe de entidade indicados: asserção indicada: a asserção falhou: template: na linha e na coluna indicadas: execução da asserção indicada na referência indicada: o mapa não tem nenhuma entrada para a chave indicada)
e onde o que falhou foi a avaliação, e não o predicado:
<entity-kind>"<type>" instance "<instance>" assertion "<name>": assertion "<kind>/<type>/<instance>/<name>" parse: <what the parse reported> (asserção indicada da instância indicada, do tipo e da classe de entidade indicados: análise da asserção indicada: com o resultado da análise indicado)
Um valor declarado sensível não aparece na mensagem. Onde a asserção lê um valor destes e chama fail com a sua frase escrita por extenso como uma única cadeia entre aspas — fail "…", sem nada encaminhado para ela e sem nada composto —, a mensagem contém essa frase tal como foi escrita, seja qual for o conteúdo do valor, porque a frase não cita nada daquilo que a asserção leu. Onde a sua mensagem cita o valor, a mensagem mostra <redacted> no lugar do valor. Onde a mensagem é composta de qualquer outra forma e aquilo que a asserção fez dependia daquilo que o valor contém, a mensagem a seguir à expressão com falha é substituída por failure text withheld: this template reads a value declared sensitive, and the failure depends on what that value holds; a interrupção e o seu código mantêm-se inalterados. O que conta como declarado, e que recusas ficam fora disto, está em vocabulary/compact-form-authoring.md «O que uma recusa diz sobre um valor declarado».
Verificada isoladamente, uma entidade comunica uma asserção com falha como um aviso.aggrega validate com o ficheiro de uma Recipe, a verificação desse ficheiro pelo editor através de aggrega serve e a ferramenta validate de aggrega mcp com uma entity constroem a Recipe em torno de marcadores de posição e valores predefinidos do esquema em vez dos valores que uma Release define, pelo que não conseguem distinguir uma asserção que aguarda uma Release de uma que está avariada. Aí, uma asserção que chama fail — a própria da Recipe, ou uma que o Component que ela implementa declara — é comunicada como um aviso que traz a mensagem acima, fechada pela frase A Release must satisfy this assertion before a build of it can pass., e a verificação passa. Uma referência a uma chave que nada fornece e uma asserção cuja análise falha não são asserções com falha: cada uma é um defeito no próprio texto da asserção, e essa verificação julga-a como julga qualquer outro defeito. Uma compilação tem sempre uma Release, e é interrompida na asserção como aqui descrito; ver uma asserção com falha é um aviso.
Como corrigir: a mensagem depois dos últimos dois pontos é do autor da asserção, e é ela que diz o que mudar — uma asserção é escrita de modo que encontrá-la dê a resposta. Onde a comunicação é uma chave em falta em vez da frase do autor, o defeito está na própria asserção: corrigir a referência, ou condicioná-la como descrito acima. Onde a regra não se deveria aplicar a esta Release, trata-se de uma questão sobre a entidade que traz a asserção, e não sobre o ficheiro de quem a lê.
A pipeline step addresses documents the node does not have (Um passo de pipeline endereça documentos que o nó não tem)
Um passo de pipeline endereça um documento por um âmbito e uma chave. Três condições abrangem as formas como um endereço não alcança nada, e cada uma para a compilação em vez de deixar um passo comunicar sucesso sobre uma edição que nunca aconteceu.
O nó não o emitiu. Um patch nomeia um par de âmbito e chave que não está entre os documentos que este nó produziu:
node "<instance>": pipeline PATCH targets a document the node did not emit (nó indicado: o PATCH de pipeline aponta para um documento que o nó não emitiu)
Não há nenhum anfitrião a endereçar. Um passo procurou os documentos de um componente anfitrião num ponto em que não há nenhum — o pipeline próprio de um componente, cujo único âmbito é a sua própria saída, ou uma Feature anexada a uma fronteira em vez de a um único componente. O âmbito do anfitrião está vazio onde quer que um pipeline destes seja executado, pelo que um endereço dentro dele não se resolve face a nada:
node "<instance>": pipeline /host operation from a step with no host component (nó indicado: operação /host de pipeline a partir de um passo sem componente anfitrião)
O documento não traz nenhuma árvore a endereçar. Algumas unidades não têm nenhuma estrutura para a qual um caminho possa apontar — um corpo binário, texto livre, uma região que o destino não consegue percorrer em segurança. Uma unidade destas é ainda assim entregue ao passo, para que possa ser selecionada e emitida por inteiro; o que não pode é receber um patch:
node "<instance>": pipeline PATCH target is not parseable structured YAML/JSON (nó indicado: o destino do PATCH de pipeline não é YAML/JSON estruturado analisável) pipeline PATCH target is not parseable structured YAML/JSON (node "<instance>", document "<key>") (o destino do PATCH de pipeline não é YAML/JSON estruturado analisável (com o nó e o documento indicados))
Cada uma chega com o relato próprio do percurso sobre o endereço por baixo dela, e cada uma é posicionada na instância de componente cujo pipeline a produziu.
Duas das três também são comunicadas antes de qualquer percurso. Se um ponto tem ou não documentos do anfitrião decorre de onde o pipeline foi escrito, pelo que um passo que declara operar sobre documentos do anfitrião num ponto que não os tem é nomeado assim que a compilação sabe o que cada plugin declara, sem esperar que um nó seja renderizado — e uma Feature anexada a uma fronteira é nomeada junto ao passo:
pipeline /host operation from a step with no host component (operação /host de pipeline a partir de um passo sem componente anfitrião) pipeline /host operation from a step with no host component ("<attachment>") (operação /host de pipeline a partir de um passo sem componente anfitrião (com o anexo indicado))
As duas leituras são uma divisão de uma única condição, e não a mesma constatação duas vezes: o que uma declaração pode resolver é resolvido a partir da declaração, e o que só a execução pode ver fica com a execução — um passo que declara o seu próprio âmbito pode ainda assim devolver uma operação face a outro.
Estas três são a forma que para a compilação das recusas de endereçamento que o próprio percurso do pipeline comunica, documentadas sob «A pipeline patch addresses a document the set does not hold, or one with no tree to address (Um patch de pipeline endereça um documento que o conjunto não contém, ou um sem árvore a endereçar)» mais acima.
Como corrigir: as três cabem ao autor do passo, e não a quem escreve os documentos. Para um alvo ausente, aplicar o patch a um documento que o nó de facto emite, ou emitir aquele que se pretendia num passo anterior e aplicar-lhe o patch num passo posterior — um passo pode ler que chaves recebeu. Para um anfitrião em falta, mover o passo para um ponto em que haja um componente anfitrião, endereçar antes os documentos próprios do ponto, ou removê-lo. Para uma unidade sem árvore, substituir o patch por uma emissão da unidade inteira: um corpo opaco é substituído, e não editado.
A pipeline patch addresses output that has not been assembled yet (Um patch de pipeline endereça uma saída que ainda não foi montada)
Alguns fornecedores combinam a saída por nó de um grupo de encaminhamento num único documento — um ficheiro compose fundido, um chart guarda-chuva. Até essa fusão acontecer, não há documentos separados, apenas fragmentos, pelo que um patch que endereça um deles não tem nada para onde apontar. Um pipeline face a um componente destes é, por isso, adiado por inteiro e reexecutado assim que a fusão produziu os documentos, o que é o caminho comum e não exige nada do autor.
Esta condição é o que chega à compilação quando um patch alcança um fragmento mesmo assim. O caso que nomeia é a saída própria de uma Feature anexada. Onde o fornecedor do componente combina o seu grupo, todo o pipeline do anexo é retido até que a fusão tenha produzido os documentos — e o que essa reexecução recebe são apenas os documentos do componente. Um passo face à saída própria da Feature só é oferecido enquanto o componente é renderizado, ou seja, antes de qualquer fusão ter acontecido, pelo que não tem nada a endereçar. Isso vale seja qual for a forma como a saída própria da Feature circula: quer entre na fusão, quer seja escrita como documentos próprios, o seu próprio âmbito nunca é o âmbito que a reexecução traz.
A emissão nunca é afetada. Uma emissão acrescenta um documento em vez de editar um, e é executada por nó com cada fornecedor, pelo que fica totalmente fora disto.
A condição é comunicada antes de qualquer percurso, a partir daquilo que os plugins e os fornecedores declaram, e de novo como salvaguarda enquanto um nó é renderizado. Mensagens emitidas:
pipeline PATCH targets an assembler provider’s pre-assembly fragments ("<attachment>") (o PATCH de pipeline aponta para os fragmentos de pré-montagem de um fornecedor montador (com o anexo indicado)) 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 (o PATCH de pipeline aponta para os fragmentos de pré-montagem de um fornecedor montador (nó indicado; o documento indicado, no âmbito indicado, é renderizado por um fornecedor montador). a fase de pós-montagem reexecuta este PATCH assim que os documentos estão separados)
Como corrigir: endereçar os documentos do componente em vez dos próprios da Feature, que é a forma reexecutada após a fusão; ou colocar o componente num fornecedor que não combine o seu grupo de encaminhamento; ou remover o passo. Qual das três é a certa depende daquilo que o passo devia mudar, e a mensagem nomeia o âmbito que endereçou para que se possa saber. Mudar a capability: própria da FeatureRecipe não está entre elas: isso não muda que âmbito a reexecução após a fusão recebe, e é precisamente disso que esta condição trata.
A pipeline step’s plugin does not claim the provider rendering what it addresses (O plugin de um passo de pipeline não reivindica o fornecedor que renderiza aquilo que o passo endereça)
Um plugin usado por um passo de pipeline pode declarar os fornecedores com os quais foi testado. Essa lista é uma reivindicação explícita, e não um «qualquer coisa parecida» implícito: executar um plugin com um fornecedor que ele não nomeia arrisca um patch escrito para outra forma de saída, pelo que a compilação para em vez de tentar.
O fornecedor com o qual um passo é comparado é aquele que renderiza os documentos que esse passo endereça — o fornecedor próprio do componente para um passo face aos documentos do componente, e o fornecedor próprio da Feature para um passo face aos da Feature. Numa Feature anexada a um componente surgem ambos, e são dois valores diferentes de dois documentos diferentes.
Uma lista de reivindicações vazia ou ausente não corresponde a nada, pelo que cada passo que usa um plugin destes é comunicado aqui. Um plugin que a compilação não conseguiu consultar é um caso diferente e não é comunicado aqui: uma autodeclaração impossível de obter é a ausência de uma reivindicação, e não uma reivindicação vazia, e um passo destes para com a própria falha de resolução, de carregamento ou de autodeclaração, que é aquilo que deve ser reparado.
A condição é comunicada assim que a compilação sabe o que cada plugin declara sobre si mesmo, antes da execução que invocaria o passo, e uma vez por passo escrito em vez de uma vez por compilação — assim um autor vê todos os passos problemáticos de um pipeline a partir de uma única compilação. Os nomes de Provider são comparados de forma exata.
Mensagens emitidas, a primeira a partir do pipeline próprio de um componente e a segunda a partir do de uma Feature, que também nomeia o anexo:
pipeline plugin is not compatible with the rendering provider ("<provider>") (o plugin de pipeline não é compatível com o fornecedor que renderiza, o indicado) pipeline plugin is not compatible with the rendering provider ("<attachment>", "<provider>") (o plugin de pipeline não é compatível com o fornecedor que renderiza (com o anexo e o fornecedor indicados))
Como corrigir: a constatação é posicionada no passo escrito, e o fornecedor que nomeia é aquilo com que a declaração tem de ser conciliada. Quando o plugin é da autoria de quem lê, acrescentar o fornecedor à compatibilidade que declara, depois de o ter testado com ele. Onde não é, selecionar uma versão do plugin que reivindique o fornecedor, renderizar esse âmbito através de um fornecedor que o plugin reivindique, ou remover o passo.
A provider refused a node’s input (Um fornecedor recusou a entrada de um nó)
Um fornecedor pode verificar a entrada que recebe para um componente antes de a renderizar, e comunicar aquilo que encontra. As constatações com severidade de interrupção interrompem a compilação; as constatações com severidade de aviso e de informação são apresentadas a par da saída da compilação e não alteram nada nos bytes emitidos.
Esta é a leitura que o próprio fornecedor faz da entrada, e não a do compilador, pelo que aquilo a que se opõe e o grau de precisão com que o diz cabem ao fornecedor decidir. O compilador nomeia o componente e o fornecedor, e transmite as mensagens do fornecedor tal como foram devolvidas; quando um fornecedor comunicou várias, chegam juntas separadas por ponto e vírgula, pelo que uma única compilação dá conta de todas elas.
O mesmo encaminhamento é usado quer a entrada pertença à Recipe própria de um componente, quer a uma Feature anexada, pelo que a verificação de um fornecedor se lê de forma idêntica nos dois casos.
Mensagem emitida:
provider rejected node input: node "<instance>", provider "<provider>": <the provider's messages> (o fornecedor rejeitou a entrada do nó: com o nó, o fornecedor e as mensagens do fornecedor indicados)
Como corrigir: ler as mensagens do fornecedor — nomeiam aquilo que não pôde aceitar na entrada resolvida. A entrada é montada a partir dos valores da Recipe e da configuração própria do componente, pelo que a correção está normalmente num deles; a página de referência própria do fornecedor indica o que exige. Quando o fornecedor se opõe a algo que não é possível alterar a partir de um documento, essa é uma questão para quem escreveu a Recipe ou o plugin.
A provider rendered the same input twice and produced different output (Um fornecedor renderizou a mesma entrada duas vezes e produziu saídas diferentes)
Dada uma entrada idêntica, uma compilação produz uma saída idêntica — é esse o contrato com base no qual as ferramentas de revisão e as ferramentas de implementação leem o resultado de uma compilação. Um modo de compilação opcional verifica-o diretamente: cada componente é renderizado duas vezes a partir da mesma entrada e os bytes emitidos são comparados. Um fornecedor cujas duas renderizações divergem transporta estado de uma para a outra, ou, de outro modo, não é uma função da sua entrada, e a compilação para.
A compilação comum renderiza cada componente uma vez, pelo que esta condição só é encontrada no modo de verificação. Nada numa compilação normal muda pelo facto de esse modo estar disponível.
O que é comparado é a saída bruta emitida pelo fornecedor — os mesmos bytes a partir dos quais os artefactos renderizados são recortados —, pelo que é detetada uma diferença em qualquer ponto daquilo que produziu, e não apenas uma diferença que sobreviva até um ficheiro final.
Mensagem emitida:
rendering node "<instance>": node "<instance>" (provider "<provider>"): two renders of identical input produced different output: provider render is not deterministic (renderização do nó indicado: nó indicado, com o fornecedor indicado: duas renderizações de uma entrada idêntica produziram saídas diferentes: a renderização do fornecedor não é determinística)
Como corrigir: primeiro descobrir aquilo que difere entre duas compilações do componente que a mensagem nomeia — compilá-lo duas vezes e comparar as saídas. Quando a diferença é um valor que um chart usado como fonte gera de novo a cada renderização — uma palavra-passe aleatória, uma chave gerada, um carimbo temporal num Secret ou numa ConfigMap —, a falha está na saída desse chart, e não no fornecedor, e é possível eliminá-la diretamente de uma de duas formas. Fornecer o valor, através da definição que o chart ofereça para ele, a partir do valuesMapping: da Recipe, para que o chart deixe de o gerar. Ou, quando o documento gerado é um que a Release não deve entregar — um Secret que o operador fornece separadamente, por exemplo —, deixá-lo de fora da compilação com uma entrada omits: na Recipe; consulte Recipe → O campo omits:. Caso contrário, a falha é do fornecedor, e não dos documentos, e nada que se possa escrever a elimina. Comunicá-la a quem publica o plugin que serve esse fornecedor, nomeando o componente que a mensagem identifica — as causas habituais são um carimbo temporal, um valor aleatório ou uma ordenação que segue a iteração de um mapa em vez da ordem que o autor escreveu. Até ser corrigida, o modo de compilação comum não é afetado, e fixar o plugin numa versão que passou na verificação é a resposta prática.
An omits entry left out nothing the source rendered (Uma entrada omits não deixou de fora nada do que a fonte renderizou)
Cada entrada da lista omits: de uma Recipe ou de uma FeatureRecipe que se aplica a uma compilação — com o seu when: ausente, vazio ou verdadeiro — tem de deixar de fora da saída pelo menos uma coisa que a fonte renderizou: um documento que um chart renderiza, um serviço, um volume ou uma config que um ficheiro compose declara, ou um recurso que um template CloudFormation declara. O fornecedor que renderiza a fonte compara cada entrada com aquilo que renderizou e comunica quantas unidades cada uma deixou de fora; uma entrada que não deixou nenhuma de fora interrompe a compilação.
Uma entrada que não corresponde a nada é uma afirmação sobre a fonte que deixou de ser verdadeira. A causa habitual é uma atualização da fonte que renomeou ou removeu aquilo que a entrada nomeia — e um documento ou serviço renomeado fica então na saída com o seu novo nome, que é exatamente aquilo que a entrada foi escrita para manter de fora —, e a outra é um erro na própria entrada. Ignorá-la entregaria aquilo que a entrada devia deixar de fora, pelo que a compilação para e nomeia a entrada.
A mensagem nomeia o nó, o fornecedor, o documento que declara a entrada e a posição da entrada na lista omits: desse documento, contando a partir de 0, e o kind, o nome e o namespace em que a entrada se resolveu, o namespace apenas quando a entrada nomeia um. Para uma FeatureRecipe anexada a um componente, o nó é esse componente; para uma anexada a uma fronteira, a linha acima da mensagem nomeia o anexo e a sua fronteira. Quando várias entradas não corresponderam a nada, a nomeada é a primeira pela ordem em que foram escritas, pelo que a mesma entrada é nomeada em cada execução. Um campo cujo template leu um valor declarado sensível é mostrado como <redacted> em vez de como aquilo em que se resolveu. Uma entrada que o seu when: descartou nunca é entregue ao fornecedor nem verificada.
Mensagem emitida. A categoria chega no cabeçalho entre parênteses retos:
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 (uma entrada omits não deixou de fora nada do que a fonte renderizou (com o nó, o fornecedor, a posição na lista omits do documento, o kind, o nome e o namespace indicados). corrigir a entrada para que nomeie algo que a fonte renderiza, ou removê-la; a causa habitual é uma atualização da fonte que renomeou ou removeu aquilo que nomeava)
O cabeçalho transporta o código curto desta condição, E0334.
Como corrigir: comparar a entrada com aquilo que a fonte renderiza agora — compilar com a entrada removida e ler aquilo que o componente renderiza —, e depois corrigir o kind, o nome ou o namespace da entrada, ou remover a entrada quando aquilo que nomeava já não existe. Para um chart, uma entrada nomeia um documento pelo kind e pelo metadata.name próprios do documento e, quando a entrada nomeia um namespace, pelo namespace em que o documento está; para um ficheiro compose, nomeia um service, um volume ou um config pela sua chave; para um template CloudFormation, nomeia um recurso pelo seu Type e pelo seu ID lógico, em qualquer um dos templates da fonte. Consulte Recipe → O campo omits:.
A provider’s omitted counts do not match the omits entries it was handed (As contagens de omissões de um fornecedor não correspondem às entradas omits que recebeu)
Um fornecedor que declara deixar de fora unidades renderizadas comunica, para cada entrada omits: que recebeu, com quantas unidades essa entrada correspondeu — uma contagem por entrada, pela ordem em que as entradas foram entregues. Uma comunicação em falta, que contém contagens a menos ou a mais, ou que contém uma contagem abaixo de zero não deixa forma de saber se uma entrada deixou algo de fora, pelo que a compilação para. Nada do que foi escrito causa isto: a condição assinala um fornecedor cuja saída devolvida não cumpre o contrato que declara.
Mensagem emitida. A mensagem nomeia o nó e o fornecedor, depois quantas entradas foram entregues e aquilo que voltou — ou quantas contagens, ou a contagem abaixo de zero e a entrada para a qual foi dada:
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) (as contagens de omissões de um fornecedor não correspondem às entradas omits que recebeu (com o nó e o fornecedor indicados, o número indicado de entradas omits entregues e o número indicado de contagens de omissões devolvidas))
O cabeçalho transporta o código curto desta condição, E0336.
Como corrigir: comunicá-lo a quem publica o plugin que serve esse fornecedor, nomeando o componente que a mensagem identifica. Aquilo que um fornecedor deve cumprir está descrito no contrato de plugins em Deixar unidades renderizadas de fora.
Assembled output still carries a cross-boundary placeholder (A saída montada ainda transporta um marcador de posição entre fronteiras)
Quando uma conexão de dependência atravessa duas saídas montadas, o valor que transporta não pode ser conhecido enquanto o lado consumidor é renderizado — é publicado pelo outro lado e resolvido assim que ambos tiverem sido montados. Por isso, a compilação escreve um marcador de posição na entrada do componente consumidor, e o fornecedor substitui-o pela sua própria forma de referência cruzada assim que a montagem existe.
Esta condição é o que comunica um marcador de posição que sobreviveu a essa substituição. Sobreviver significa que a resolução nunca o alcançou: o valor foi parar num sítio que o fornecedor não conseguia endereçar — inserido numa string mais longa em vez de figurar como um valor inteiro, na maioria das vezes —, ou uma travessia foi marcada sem nada do outro lado para a resolver. Um marcador de posição nunca é uma saída válida, pelo que a compilação para em vez de entregar um ficheiro que contenha um.
A mensagem nomeia o fornecedor que escreveu o ficheiro e o caminho em que o ficheiro está: um caminho só é único dentro de uma mesma montagem, pelo que são os dois em conjunto que identificam um ficheiro. Cada ficheiro problemático é comunicado, e não apenas o primeiro, e cada um é comunicado uma única vez, por mais fronteiras que tenham alimentado a montagem em que está. É comunicado sobre o documento da Release como um todo, e não sobre uma fronteira dentro dele — a falha está na forma como um valor chegou ao ficheiro, e não numa declaração de fronteira, pelo que nenhuma declaração de fronteira é aquilo que deve ser alterado.
Mensagem emitida:
assembled output retains an unresolved cross-boundary link placeholder ("<provider>", "<output-path>") (a saída montada retém um marcador de posição de ligação entre fronteiras não resolvido (com o fornecedor e o caminho de saída indicados))
Como corrigir: a causa mais comum é um valor que o lado consumidor interpolou numa string mais longa. Uma referência cruzada tem de constituir a totalidade do valor como o qual é injetada, pelo que se deve mudar o mapeamento da Recipe para a entregar inteira e, em vez disso, compor em torno dela no vocabulário próprio do destino. Quando o valor está inteiro e o marcador de posição sobrevive mesmo assim, a falha está do lado do fornecedor na resolução e cabe a quem publica esse plugin.
A template did more than copy a value it read off a cross-boundary link (Um template fez mais do que copiar um valor que leu de uma ligação entre fronteiras)
Um template pode ler os valores de um produtor diretamente de uma conexão, em .context.uses.<alias>.provides — ou, numa FeatureRecipe com âmbito de fronteira, das conexões da fronteira sob .boundary. Quando a conexão une dois componentes que renderizam em saídas diferentes e o fornecedor a liga com uma referência própria, cada um desses valores chega ao template como um marcador de posição que o fornecedor substitui assim que ambas as saídas estão montadas: por uma referência entre stacks, ou pelo próprio valor. Por isso, um template só pode copiar um valor destes — escrevê-lo inteiro, dentro de uma string mais longa, ou através de uma função que o deixe tal como está, como quote.
Uma comparação, uma ramificação, um comprimento ou uma função que altera o valor — eq, if, len, upper, trimPrefix — seria decidido com base no marcador de posição, e não no valor, silenciosamente. A compilação verifica-o avaliando o template duas vezes, uma sobre os marcadores de posição e outra sobre os valores reais, e interrompe-se onde os dois divergem assim que cada marcador de posição é reescrito. Aplica-se a cada template que lê uma conexão destas: os templates próprios de uma Recipe, o injectMapping: de uma FeatureRecipe anexada e os templates de uma FeatureRecipe com âmbito de fronteira.
A mensagem nomeia o template — o campo e a Recipe a que pertence — e, para cada valor provides de que a diferença depende, o componente consumidor, o alias e o socket da conexão, e o componente produtor. Um valor que o template apenas copiou não é nomeado.
Mensagem emitida:
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 (um template faz mais do que copiar um valor que lê de uma ligação entre fronteiras (com o template indicado e a chave provides indicada que o componente consumidor indicado lê da sua conexão indicada, no socket indicado, para o componente produtor indicado). Copiar o valor tal como está, inteiro ou dentro de uma string mais longa, porque o fornecedor escreve no seu lugar aquilo em que o valor se torna na outra saída, e, em vez disso, ramificar com base num valor próprio do componente)
Como corrigir: copiar o valor que a mensagem nomeia em vez de o testar ou transformar, e basear a decisão num valor que o próprio componente consumidor escreve — uma das suas próprias chaves values ou infra — em vez de naquilo que a sua conexão lê. O fornecedor CloudFormation descreve em que se torna um valor copiado no outro stack.
A provider named a directory for a contributor that is not one directory (Um fornecedor nomeou para um contribuidor um diretório que não é um único diretório)
Um fornecedor que coloca cada contribuidor sob a sua própria posição dentro de uma mesma saída envolvente declara o diretório sob o qual essas posições ficam, e a compilação compõe nele a identidade de cada componente. O valor tem de nomear exatamente um diretório: um valor que contenha um separador de caminho, ou que nomeie o diretório atual ou o diretório pai, colocaria os ficheiros de um componente noutro sítio que não sob a sua própria posição — ou totalmente fora da montagem, ou reorganizados silenciosamente dentro dela.
A compilação para em vez de compor um caminho destes. A mensagem nomeia o fornecedor que declarou o valor e o próprio valor, pelo que fica claro que fornecedor alterar e o que declarou.
Um fornecedor que não declara nenhum diretório destes não é afetado. Cada contribuidor fica então diretamente no diretório de implementação sob o seu próprio nome, pelo que não nomear um diretório envolvente é uma resposta legítima, e não uma omissão.
Mensagem emitida:
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 (o fornecedor nomeou, para o subdiretório próprio de cada contribuidor, um diretório que não é um único nome de diretório: o fornecedor indicado declarou nest_segment com o valor indicado; o valor deve nomear um só diretório, sem separador de caminho e sem nomear nem o diretório atual nem o diretório pai)
Como corrigir: nada em nenhum documento de catálogo produz este valor, pelo que não há nada a corrigir nos ficheiros próprios — vem do plugin que serve o fornecedor. Comunicá-lo a quem publica esse plugin, citando o valor que a mensagem nomeia. Quando o plugin é da autoria de quem lê, declarar um único nome de diretório, ou não declarar nenhum e deixar cada contribuidor ficar no diretório de implementação.
A boundary-scope Feature is attached only to a component (Uma Feature de âmbito de fronteira está anexada apenas a um componente)
Uma FeatureRecipe pode declarar que gera uma única vez para uma fronteira, em vez de uma vez para cada componente — um recurso partilhado para tudo o que a fronteira contém, em vez de um por componente. Por isso, a fronteira é onde um anexo destes tem de ser escrito: um anexo com esse nome escrito apenas num componente não nomeia nenhum âmbito para o qual a receita possa gerar, pelo que nada decide em que fronteira seria executado, que valores leria ou onde a sua saída seria escrita.
Escrevê-lo também num componente é comum e não é comunicado. Um anexo declarado numa fronteira chega a todos os componentes que essa fronteira contém, incluindo os dos âmbitos aninhados no seu interior, pelo que transportá-lo é a forma normal. O que é verificado é se o âmbito próprio do componente, ou um que o envolve, declara o nome — a procura avança para fora a partir de onde o componente se encontra e para no primeiro âmbito que o declara. Um componente que repete em si próprio um anexo que o seu âmbito envolvente já declara é renderizado exatamente como a forma declarada apenas no âmbito, e é admitido pelo mesmo motivo.
Um componente colocado em nenhum âmbito não tem nada a percorrer, pelo que um anexo de âmbito de fronteira nesse componente é comunicado aqui — que é a leitura honesta, uma vez que não há nenhum âmbito para o qual uma receita destas possa gerar.
Mensagem emitida, que nomeia o anexo e o âmbito em que o componente se encontra:
attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>", on a component in boundary "<boundary>") (o anexo associa uma FeatureRecipe com executionScope: boundary e nenhuma fronteira que contém o componente o declara (com o anexo indicado, num componente na fronteira indicada))
e, para um componente em nenhum âmbito, que não contribui com nenhum valor desse tipo:
attachment binds a FeatureRecipe with executionScope: boundary and no boundary holding the component declares it ("<attachment>") (o anexo associa uma FeatureRecipe com executionScope: boundary e nenhuma fronteira que contém o componente o declara (com o anexo indicado))
Como corrigir: declarar o anexo sob features: na fronteira para a qual deve gerar — o âmbito em que o componente se encontra, ou um que o envolva — em vez de apenas no componente. Onde o que se pretendia era uma geração por componente, anexar em vez disso uma Feature cuja FeatureRecipe não declare o âmbito de fronteira.
The sandbox refused a plugin (A sandbox recusou um plugin)
Cada plugin comunica o que é e aquilo de que precisa antes de lhe ser permitido fazer qualquer trabalho, e a sandbox confronta essa comunicação com aquilo que está disposta a conceder. Esta condição abrange toda a classe de comunicações que a sandbox não aceita, e a frase diz qual a parte que foi recusada: uma versão da interface de plugins que o anfitrião não fala, um tipo de plugin para o qual o anfitrião não tem vocabulário, um plugin que pede acesso de saída à rede ou acesso ao sistema de ficheiros, um plugin que nomeia uma chamada ao anfitrião fora do conjunto que o anfitrião oferece ou que importa de um namespace fora do conjunto que admite, um export em falta ou malformado, um campo que traz um valor fora do conjunto a que está restrito, ou uma autodeclaração que não é de todo legível.
A recusa acontece antes de o plugin ser executado, e um plugin recusado é encerrado antes de a falha se propagar, pelo que nada do que pediu é concedido, nem sequer por um instante.
Parte daquilo que um plugin não pode ter não é verificada aqui, porque nunca é concedida. O anfitrião dá a um convidado um relógio congelado, nenhum sistema de ficheiros, nenhum ambiente e nenhum sítio para onde a sua própria saída possa ir, pelo que um convidado que tente alcançar qualquer um deles falha na tentativa, em vez de ser recusado à partida. O que esta condição abrange é a comunicação que o plugin faz sobre si próprio, verificada antes de arrancar.
Mensagens emitidas. A frase da condição fecha cada uma, e o que a precede nomeia o plugin e a parte da sua comunicação que foi recusada. Uma versão de interface que o anfitrião não fala:
plugin "<plugin>" declares abi_version "<declared>"; host speaks "<supported>": wasm: plugin rejected by the sandbox (o plugin indicado declara a abi_version indicada; o anfitrião fala a versão suportada indicada: wasm: plugin recusado pela sandbox)
um tipo de plugin para o qual o anfitrião não tem vocabulário:
plugin "<plugin>" declares unknown plugin_type "<declared>": wasm: plugin rejected by the sandbox (o plugin indicado declara um plugin_type desconhecido, o indicado: wasm: plugin recusado pela sandbox)
uma autodeclaração que não pode ser lida:
wasm: plugin "<plugin>" describe() output is not valid JSON: <what the read reported>: wasm: plugin rejected by the sandbox (wasm: a saída de describe() do plugin indicado não é JSON válido: com o resultado da leitura indicado: wasm: plugin recusado pela sandbox)
um plugin a que falta o export que o seu tipo exige, nomeado a partir do mesmo registo de onde o próprio tipo é lido:
<kind> plugin "<plugin>" declares no "<export>" export: wasm: plugin rejected by the sandbox (o plugin indicado, do tipo indicado, não declara o export indicado: wasm: plugin recusado pela sandbox)
um campo restrito a um conjunto fixo que traz outra coisa — a mesma forma abrange o modo de montagem e os campos operates e scope de cada export:
plugin "<plugin>" export "<export>" declares unknown scope "<declared>" (want "own", "host", or empty): wasm: plugin rejected by the sandbox (o export indicado do plugin indicado declara um âmbito desconhecido, o indicado (esperado um dos valores indicados, ou vazio): wasm: plugin recusado pela sandbox)
uma capacidade emparelhada declarada sem os seus dois exports, ou os exports sem a reivindicação:
plugin "<plugin>" declares the cross-boundary linking capability but does not export both "link_publish" and "link_resolve": wasm: plugin rejected by the sandbox (o plugin indicado declara a capacidade de ligação entre fronteiras, mas não exporta os dois exports indicados: wasm: plugin recusado pela sandbox)
um nome de capacidade que nenhuma Recipe poderia alguma vez selecionar — um fornecedor que serve um nome que contém dois pontos, ou um passo de pipeline compatível com um deles — porque o capability: de uma Recipe é lido como o nome até aos seus últimos dois pontos, seguido de uma fixação de versão. O parse:<format> de um parser e o import:<format> de um importador não são recusados: os dois pontos fazem parte desses nomes, e são procurados por formato, e não através de uma Recipe. A mesma recusa impede que a entidade de um plugin destes seja gerada para publicação:
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 (o plugin indicado (com o plugin_type indicado) serve a capacidade indicada, que contém dois pontos; a referência de capacidade de uma Recipe é lida como a capacidade até aos seus últimos dois pontos, seguida de uma fixação de versão, pelo que nenhuma Recipe pode nomear essa capacidade: comunicar o nome da capacidade sem dois pontos: wasm: plugin recusado pela sandbox)
e as chamadas ao anfitrião que um plugin reivindica face às que o seu binário efetivamente usa, o que é verificado nos dois sentidos, para que um plugin não possa nem anunciar uma superfície que não usa nem esconder uma que usa:
plugin "<plugin>" declares host function "<name>" in describe() that its wasm does not import: wasm: plugin rejected by the sandbox (o plugin indicado declara em describe() a função do anfitrião indicada, que o seu wasm não importa: wasm: plugin recusado pela sandbox) plugin "<plugin>" imports host function "<name>" that its describe() does not declare: wasm: plugin rejected by the sandbox (o plugin indicado importa a função do anfitrião indicada, que o seu describe() não declara: wasm: plugin recusado pela sandbox)
Como corrigir: nada nos ficheiros de entidade causa isto, e nenhuma alteração de autoria o elimina — a comunicação recusada é a do próprio plugin. Quando se consome um plugin publicado, comunicar a mensagem a quem o publica e, entretanto, selecionar uma versão que o anfitrião aceite. Quando o plugin é da sua autoria, a mensagem nomeia o campo e os dois valores, pelo que a correção é aquela para a qual a frase aponta: falar a versão de interface que o anfitrião fala, declarar um tipo que ele conheça, manter cada campo dentro do conjunto a que está restrito, declarar o export que o tipo exige e declarar exatamente as chamadas ao anfitrião que o binário usa — nem mais, nem menos.
A plugin is not the kind of plugin the socket expects (Um plugin não é do tipo de plugin que o socket espera)
Cada ponto de anexo indica para que tipo de plugin encaminha, e cada plugin comunica o seu próprio tipo. Esta condição é o que comunica uma divergência entre os dois: um plugin que serve um fornecedor anexado onde se espera um linter, um parser anexado onde se espera um importador, um plugin que não é um comando de terminal executado como tal. A verificação acontece quando o plugin é carregado, pelo que um plugin do tipo errado nunca chega ao trabalho que lhe teria sido pedido.
O motivo pelo qual para, em vez de tentar mesmo assim, é que os tipos não partilham uma interface. Um plugin de outro tipo seria chamado através de exports que não tem, e o que voltasse seria lido face a uma estrutura que nunca produziu.
A leitura da autodeclaração de um plugin sem afirmar um tipo não é afetada. Uma superfície que só quer saber o que um plugin diz sobre si próprio — listar o que está configurado, gerar uma entidade para um plugin — não exprime nenhuma expectativa, e esta verificação é aí saltada.
Mensagem emitida, que nomeia o plugin e os dois tipos, com o tipo esperado indicado por extenso, além do seu 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: o plugin indicado: era esperado um plugin do tipo indicado por extenso (com o tipo de plugin esperado indicado), mas o seu describe() comunica o tipo de plugin indicado: wasm: o tipo de plugin declarado não corresponde ao describe() do plugin)
Como corrigir: anexar um plugin do tipo que o ponto de anexo aceita — a mensagem nomeia o tipo esperado. Quando o plugin é aquele que se pretendia, o anexo está no sítio errado: movê-lo para a superfície a que pertence o tipo do plugin. Quando o plugin é da sua autoria e devia ser do tipo esperado, está a comunicar o tipo errado sobre si próprio, e essa é uma correção no plugin, e não na configuração que o anexa.
A plugin failed while it was running (Um plugin falhou durante a execução)
Um plugin a que se pediu que fizesse algo não voltou com um resultado. Três condições abrangem este caso, e o que as separa é apenas a forma como a falha se propagou — um plugin que foi abaixo, um plugin que interrompeu a sua própria execução e um plugin que foi executado até ao fim e comunicou que não conseguia fazer o que foi pedido. Formam deliberadamente uma única taxonomia, para que uma compilação trate da mesma forma todas as maneiras como um plugin pode falhar.
Um plugin que foi abaixo. A maioria das falhas dentro de um plugin — uma instrução inalcançável, uma divisão por zero, uma leitura fora da sua memória — é convertida em falhas comuns à saída e nunca chega a esta condição. Esta é a rede de segurança por trás desse caminho, para uma queda que lhe escape.
Um plugin que interrompeu a sua própria execução. Um plugin que pede para terminar está a fazer algo para o qual o modelo de plugins não tem uso: um plugin devolve o seu resultado através da chamada com que foi invocado, e não terminando. A sua própria execução para; o processo da compilação não é afetado.
Um plugin que comunicou uma falha. O envelope de resultado que um plugin devolve tem um lugar onde pode dizer que não conseguiu concluir, e uma mensagem que o diga é transmitida como uma falha, em vez de ser lida como um resultado.
Mensagens emitidas, cada uma das quais nomeia o plugin ou o export e traz aquilo que a falha tiver fornecido. Uma queda traz o valor recuperado:
wasm: guest plugin "<plugin>" panicked in <export>: <the recovered value>: wasm: guest plugin panicked during call (wasm: o plugin convidado indicado entrou em pânico no export indicado: com o valor recuperado indicado: wasm: o plugin convidado entrou em pânico durante a chamada)
um plugin que parou por si próprio traz o código com que parou:
wasm: plugin "<plugin>" call to <export> invoked proc_exit(<code>): wasm: plugin invoked proc_exit (wasm: a chamada do plugin indicado ao export indicado invocou proc_exit com o código indicado: wasm: o plugin invocou proc_exit)
e uma falha comunicada traz a mensagem própria do plugin:
call "<export>": wasm: guest plugin reported an error: <the plugin's message> (chamada ao export indicado: wasm: o plugin convidado comunicou um erro: com a mensagem do plugin indicada)
Como corrigir: nada nos ficheiros de entidade causa nenhuma das três, e nenhuma alteração de autoria as elimina — cada uma é uma falha dentro do plugin. Comunicar a mensagem a quem o publica, nomeando o export que identifica, e fixar o plugin numa versão que funcionava enquanto é corrigido. Quando o plugin é da sua autoria: devolver uma falha no envelope de resultado, em vez de ir abaixo ou terminar, para que a compilação receba uma mensagem que possa mostrar; e, onde a falha comunicada é a resposta ponderada do próprio plugin, a sua mensagem é o que um leitor verá, pelo que vale a pena dizer o que, na entrada, não conseguiu aceitar.
A plugin returned something that is not the shape the socket reads (Um plugin devolveu algo que não tem a estrutura que o socket lê)
Cada ponto de anexo lê o resultado que recebe de volta face à estrutura que espera, e recusa tudo o resto — um campo que a estrutura não declara, um campo cujo valor não é do tipo declarado para ele, ou bytes que não são de todo um resultado bem formado.
Recusa em vez de ler o que consegue, e o motivo é que ler o que consegue seria silencioso. O export que um anexo chama pode ser escolhido por anexo, pelo que um anexo pode nomear um export cujo resultado tem uma estrutura completamente diferente. Saltar as partes que não encaixam produz um resultado vazio — e um resultado vazio é em si uma resposta legítima: nenhum veredicto devolvido, nenhuma constatação levantada. Os dois seriam então indistinguíveis, e uma compilação prosseguiria exatamente como se o plugin a tivesse aprovado.
Mensagem emitida, que nomeia o export de onde o resultado voltou e traz o motivo pelo qual a leitura falhou — em conjunto, identificam o export que o anexo devia ter nomeado:
call "<export>": wasm: guest plugin returned an output that is not the shape the socket reads: <what could not be read> (chamada ao export indicado: wasm: o plugin convidado devolveu uma saída que não tem a estrutura que o socket lê: com aquilo que não pôde ser lido indicado)
Como corrigir: verificar a função de entrada que o anexo nomeia face aos exports que o plugin declara — um anexo apontado para o export errado é a causa comum, e o motivo na mensagem nomeia o campo que não pertence à estrutura. Quando o export é o correto, o plugin está a devolver uma estrutura que o ponto de anexo não lê, o que é uma correção no plugin; comunicá-lo a quem o publica, citando tanto o export como o motivo.
A plugin returned a diagnostic at a severity that is not declared (Um plugin devolveu um diagnóstico com uma severidade que não está declarada)
Um plugin pode devolver observações juntamente com o seu resultado, e cada uma traz uma severidade de um conjunto fechado: uma que para a compilação e nomeia o que corrigir, uma que é mostrada ao lado de uma compilação que ainda assim é concluída, e uma que regista a observação e não altera nada. Uma severidade fora desse conjunto é uma para a qual o anfitrião não tem nenhum encaminhamento, e a compilação para.
Recusa em vez de escolher um encaminhamento, e ambas as alternativas são piores. Passar por cima de uma observação que não consegue encaminhar seria tratá-la como algo sem nada a fazer — o que, onde o plugin está a decidir se aceita a compilação, se lê como aprovação: uma objeção que o plugin levantou deixaria passar a compilação sem nunca ser mostrada. Tratá-la como a severidade que para a compilação rejeitaria uma compilação por um valor que ninguém escolheu. Ambas são silenciosas, pelo que o anfitrião diz que o valor está errado e, em vez disso, é o plugin que é corrigido.
A verificação é executada uma única vez, onde o resultado é lido, e não em cada sítio onde uma observação é mostrada mais tarde — que é também o único ponto em que a identidade do plugin ainda está à mão, uma vez que uma observação integrada numa comunicação já não sabe qual o plugin que a levantou.
Mensagem emitida, que nomeia o plugin, o export, qual a observação com defeito, o seu valor e os 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" (chamada ao export indicado do plugin indicado: wasm: o plugin convidado devolveu um diagnóstico cuja severidade o contrato não declara: o diagnóstico com o índice indicado tem a severidade indicada; as severidades declaradas são as três indicadas)
Como corrigir: nada nos ficheiros de entidade causa isto — o valor veio do plugin. Comunicá-lo a quem publica o plugin, citando o valor que a mensagem nomeia. Quando o plugin é da sua autoria, emitir uma das três severidades declaradas; a mensagem nomeia-as, e o índice indica qual a observação a examinar.
A provider returned two output files under one path (Um fornecedor devolveu dois ficheiros de saída sob um mesmo caminho)
Um fornecedor devolve a sua saída como uma lista de ficheiros, cada um dos quais nomeia o caminho em que é escrito. O anfitrião recolhe-os indexados por caminho e escreve os bytes de cada ficheiro tal como estão, sem executar nenhum serializador próprio. Dois ficheiros que nomeiam o mesmo caminho deixam essa coleção com dois valores para uma única chave.
Recusa em vez de escolher um, porque nenhuma das duas escolhas pode ser distinguida da outra depois. Manter o último descarta um ficheiro que o fornecedor indicou que fosse escrito; manter o primeiro descarta um posterior. De qualquer forma, a saída em disco é bem formada e tem um ficheiro a menos, sem que nada registe que um ficheiro foi descartado — e o caminho que sobreviveu é o caminho que teria sobrevivido de qualquer maneira, pelo que nada no resultado diz que ocorreu uma colisão. Qual dos dois era o pretendido é uma pergunta a que só o fornecedor pode responder.
É levantada onde quer que um fornecedor devolva ficheiros: ao renderizar um nó e ao montar a saída de um grupo de encaminhamento num único artefacto. A condição e a correção são as mesmas nos dois casos, pelo que ambos a comunicam.
Mensagem emitida, que nomeia o caminho devolvido duas vezes e o nó ou o caminho de encaminhamento para o qual foi devolvido:
provider guest returned two output files under one path; a conforming guest returns each output path at most once (path "<path>", node "<node>") (o convidado fornecedor devolveu dois ficheiros de saída sob um mesmo caminho; um convidado conforme devolve cada caminho de saída no máximo uma vez (com o caminho e o nó indicados))
Como corrigir: nada nos ficheiros de entidade causa isto — os caminhos vieram do fornecedor. Comunicá-lo a quem o publica, citando o caminho que a mensagem nomeia. Quando o fornecedor é da sua autoria, devolver cada caminho de saída no máximo uma vez: construir a lista de caminhos face a um conjunto, para que um segundo ficheiro num mesmo caminho seja detetado onde é produzido, e dar ao segundo ficheiro um caminho distinto se ambos forem pretendidos.
A provider reported a render fact whose value is not a list (Um fornecedor comunicou um facto de renderização cujo valor não é uma lista)
Um fornecedor pode comunicar, junto com os seus ficheiros, factos sobre a saída que renderizou — um nome e um valor cada, no vocabulário documentado próprio desse fornecedor — e as Features anexadas a um componente leem-nos a partir dos seus templates. O valor de cada facto é uma lista, mesmo quando contém uma única entrada: um mesmo nome pode ser comunicado por mais do que uma renderização de um componente, as chamadas ao seu próprio fornecedor e as renderizações das Features anexadas a ele, e as listas são unidas numa só sob esse nome para os templates que o leem. Um fornecedor não pode saber, ao renderizar, se a sua comunicação será a única sob um nome, pelo que um valor que seja um objeto, uma string, um número, um booleano ou null é recusado onde o fornecedor o entrega, em todas as renderizações, quer algum template leia o facto, quer não.
Mensagem emitida, que nomeia o facto, o nó para o qual foi comunicado, o fornecedor que o comunicou e de que tipo era o 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>) (o convidado fornecedor comunicou um facto de renderização cujo valor não é uma lista; um convidado conforme comunica o valor de cada facto de renderização como um array JSON, mesmo com uma única entrada (com o facto, o nó e o fornecedor indicados; o seu valor é do tipo indicado))
Como corrigir: nada nos ficheiros de entidade causa isto — o valor veio do fornecedor. Comunicá-lo a quem o publica, citando o facto que a mensagem nomeia. Quando o fornecedor é da sua autoria, comunicar o valor desse facto como um array JSON — um único objeto torna-se uma lista que contém esse objeto — e documentá-lo como lista nos factos que o fornecedor comunica; ver Comunicar factos sobre aquilo que um convidado emitiu.
A provider’s link wiring names an output file that was never emitted (A cablagem de ligação de um fornecedor nomeia um ficheiro de saída que nunca foi emitido)
Quando uma conexão atravessa dois grupos de encaminhamento, pede-se ao fornecedor de cada lado que a cable: a extremidade consumida publica uma identidade, a extremidade consumidora resolve-se face a ela, e cada uma pode devolver uma cablagem estrutural a aplicar à saída do seu próprio grupo. Cada peça de cablagem nomeia o ficheiro de saída a que se aplica. Uma passagem posterior recorta esse ficheiro, aplica as operações e remonta-o com fidelidade byte a byte.
Um nome que não corresponde a nenhum ficheiro emitido não deixa nada para essa passagem recortar, e ela recusa em vez de ignorar a cablagem. As operações que a cablagem traz são o que resolve a conexão, pelo que descartá-las deixa uma saída montada que referencia uma extremidade que nada cablou — o que falha no momento da implementação, longe do fornecedor que o causou, e parece um erro na conexão, e não na cablagem.
Os ficheiros que uma peça de cablagem pode nomear são os ficheiros que a renderização própria desse grupo devolveu. São entregues ao fornecedor na mesma chamada, pelo que o fornecedor nunca tem de adivinhar um nome: escolhe um do conjunto que recebeu.
Mensagem emitida, que nomeia o ficheiro que a cablagem pediu e a extremidade para a qual foi devolvida:
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>") (o patch de ligação nomeia um ficheiro de saída que o grupo de encaminhamento não emitiu; um patch de ligação conforme nomeia um ficheiro que a renderização própria do grupo devolveu (com o ficheiro e o nó indicados))
Como corrigir: nada nos ficheiros de entidade causa isto — o nome veio do fornecedor. Comunicá-lo a quem o publica, citando o ficheiro que a mensagem nomeia. Quando o fornecedor é da sua autoria, tirar o nome do ficheiro dos ficheiros montados que a chamada entrega, e não de um nome construído de forma independente — um caminho composto à mão fica desatualizado no momento em que muda a renderização que o produz, e é este o aspeto que isso tem.
A pipeline step’s file emission carries no file (A emissão de ficheiro de um passo de pipeline não traz nenhum ficheiro)
Um passo de pipeline pode emitir um novo documento junto com aqueles a que aplica patches. Cada emissão declara o seu tipo, e uma emissão do tipo ficheiro traz o ficheiro que escreve: o caminho e o conteúdo.
Aqui o tipo está correto e o ficheiro está ausente, pelo que o passo declarou uma intenção que a sua resposta não cumpre. É essa a diferença entre esta interrupção e a do tipo não definido mais abaixo: o anfitrião sabe exatamente o que fazer com uma emissão emit_file e não tem nada a que o aplicar.
Recusa em vez de não emitir nada, porque uma emissão que silenciosamente não contribuísse com nenhum ficheiro seria invisível. Um passo que emite um documento é muitas vezes toda a razão de estar no pipeline, e a sua saída é um ficheiro que antes não existia — pelo que uma compilação que o saltasse produziria uma saída sem um documento, enquanto o passo comunica que foi executado.
Mensagem emitida, que nomeia o nó e qual das emissões do passo estava com defeito:
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>) (o efeito secundário emit_file não traz nenhum ficheiro; um efeito secundário emit_file conforme traz um ficheiro com o seu caminho e o seu conteúdo (com o nó e o índice do efeito secundário indicados))
Como corrigir: nada nos ficheiros de entidade causa isto — a resposta veio do plugin. Comunicá-lo a quem o publica, citando o índice que a mensagem nomeia. Quando o plugin é da sua autoria, preencher o membro de ficheiro em cada emissão emit_file, com o caminho e o conteúdo; o índice indica qual a emissão da resposta desse passo a examinar.
A pipeline step declares an emission kind the contract does not define (Um passo de pipeline declara um tipo de emissão que o contrato não define)
Cada emissão que um passo de pipeline devolve declara o seu tipo, e o contrato define dois: um escreve um ficheiro, o outro contribui com um documento de recurso personalizado. O tipo é uma string aberta no formato de transmissão, e é isso que permite acrescentar um tipo posterior sem quebrar os plugins existentes.
Essa abertura é exatamente o motivo pelo qual um tipo não definido é recusado em vez de ignorado. Um valor que o anfitrião não define não pode ser distinguido, apenas pela sua estrutura, de um que uma versão posterior definirá — pelo que um anfitrião que o saltasse descartaria silenciosamente aquilo que o passo pretendia com ele, em cada compilação, enquanto o passo comunica sucesso. Recusar mantém o ponto de extensão aberto sem o transformar num buraco: um tipo que esta compilação não define é comunicado como não definido, citando o valor que o passo enviou, em vez de ser aceite e ignorado.
Mensagem emitida, que nomeia o nó, qual a emissão com defeito e o tipo que declarou:
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>") (o efeito secundário declara um tipo que o contrato de plugins não define; um efeito secundário conforme declara emit_file ou emit_crd (com o nó, o índice do efeito secundário e o tipo indicados))
Como corrigir: nada nos ficheiros de entidade causa isto — o valor veio do plugin. Comunicá-lo a quem o publica, citando o tipo que a mensagem nomeia. Quando o plugin é da sua autoria, declarar um dos tipos que a mensagem enumera; uma gralha num tipo definido é a causa comum, e o valor citado de volta é aquele que foi enviado.
A provider’s reassembly is handed a unit its own carve never produced (A remontagem de um fornecedor recebe uma unidade que o seu próprio recorte nunca produziu)
Um fornecedor cuja forma de saída não pode ser endereçada diretamente pode recortá-la por si próprio: divide um ficheiro de saída em unidades endereçáveis, cada uma sob um token, e devolve-as. Um passo de pipeline endereça então uma unidade através desse token, e a remontagem volta a inserir as unidades editadas no ficheiro com fidelidade byte a byte. As duas metades são um único contrato — os tokens sob os quais um ficheiro é recortado são os tokens que a sua remontagem resolve.
Quando a remontagem recebe um token que o recorte desse mesmo ficheiro não produziu, não há nenhum intervalo de bytes para onde o conteúdo editado possa voltar. Recusa em vez de descartar a unidade, porque uma unidade descartada produz um ficheiro bem formado ao qual falta uma edição que um passo devia fazer: nada falhou, nada está malformado, e a edição simplesmente não está lá.
As duas metades só podem divergir onde estão separadas — um codec que recorta por si próprio e toma emprestada a remontagem estrutural normalizada para o resto. Recortar sob um conjunto de tokens e remontar face a outro produz então exatamente isto. Um codec que detém as duas metades não pode chegar a isso: a sua própria remontagem responde pelos seus próprios tokens.
Mensagem emitida, que nomeia o token que não se resolveu em nada e o ficheiro face ao qual foi nomeado:
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>") (a remontagem nomeia um token de unidade com patch que o recorte não produziu; um codec conforme recorta e remonta um ficheiro sob os mesmos tokens (com o token e o ficheiro indicados))
Como corrigir: nada nos ficheiros de entidade causa isto. Quando o fornecedor é da sua autoria, fazer com que os tokens que uma metade produz sejam os tokens que a outra resolve: derivá-los uma única vez e transportá-los, em vez de os derivar de forma independente de cada lado, e, onde o recorte reescreve um ficheiro antes de o dividir, remontar face à mesma forma reescrita. Quando o fornecedor não é da sua autoria, comunicá-lo a quem o publica, citando o token que a mensagem nomeia.
A workload declares a form compose cannot express (Uma carga de trabalho declara uma forma que compose não consegue exprimir)
O fornecedor compose renderiza serviços de longa duração. Uma carga de trabalho que declara que executa uma cópia por máquina, que é executada segundo um agendamento ou que é executada uma vez e termina não tem um equivalente limpo numa única máquina, pelo que a renderização para em vez de emitir um serviço simples — que a iniciaria, a manteria em execução e representaria de forma errada aquilo que foi pedido.
Mensagem emitida. A condição nomeia o tipo de falha — um fornecedor sem expressão para algo que a compilação declara — e a frase própria do fornecedor nomeia a forma que recebeu:
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) compose: workload form "<form>" has no compose mapping; compose supports stateless and stateful only: compose cannot express this workload form (compose: a forma de carga de trabalho indicada não tem correspondência no compose; compose suporta apenas stateless e stateful: compose não consegue exprimir esta forma de carga de trabalho)
Como corrigir: onde o destino for de facto um ambiente compose de uma única máquina, exprimir o trabalho como um serviço de longa duração — as formas stateless e stateful são as duas que renderiza. Onde a forma for a pretendida, renderizar essa fronteira através de um fornecedor cujo destino tenha um equivalente: uma cópia por máquina, uma execução agendada e um job executado até à conclusão têm todos expressões diretas noutros sítios, e a escolha do fornecedor cabe à fronteira, e não à carga de trabalho.
A container declares a field compose has no primitive for (Um contentor declara um campo para o qual compose não tem primitiva)
Dois campos de contentor não têm equivalente no compose, e ambos param a renderização em vez de serem descartados.
Hooks que são executados quando um contentor arranca ou está prestes a parar. compose não tem nada que os execute, e um hook que silenciosamente não é executado é uma surpresa de correção que surge em tempo de execução, e não em tempo de compilação.
Ambiente em bloco obtido de um objeto com nome. compose consegue ler variáveis de um ficheiro, mas uma referência a um objeto não é um ficheiro — reinterpretar um como o outro mudaria aquilo que o contentor recebe sem o dizer.
Ambos são verificados para contentores comuns e para contentores executados antes do principal, pelo que o mesmo campo interrompe a compilação onde quer que seja declarado, e a mensagem nomeia o contentor de onde veio.
Mensagens emitidas. Ambas comunicam a mesma condição — um fornecedor sem expressão para algo que a compilação declara — e é a frase própria do fornecedor que diz qual o campo:
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) 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: no nó e no contentor indicados: compose: o nó indicado declara hooks de ciclo de vida do contentor; compose não tem primitiva de hook de ciclo de vida: compose não tem primitiva de hook de ciclo de vida; o contentor declara hooks de ciclo de vida)
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) 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: no nó e no contentor indicados: compose: o nó indicado declara envFrom para o contentor; compose não tem primitiva de ambiente a partir de objeto: compose não tem primitiva de ambiente a partir de objeto; o contentor declara envFrom)
Como corrigir: para um destino compose, remover o campo e fazer o seu trabalho de outra forma — o trabalho de arranque pertence a um contentor executado antes do principal, e o trabalho de encerramento ao tratamento de sinais do próprio contentor; o ambiente em bloco pode ser escrito como variáveis explícitas, ou fornecido a partir de um ficheiro que o destino compose consiga ler. Onde o campo for o pretendido, renderizar essa fronteira através de um fornecedor cujo destino tenha a primitiva.
An omits entry names a kind or a namespace a compose file does not have (Uma entrada omits nomeia um kind ou um namespace que um ficheiro compose não tem)
Uma entrada omits: numa Recipe ou numa FeatureRecipe que usa um ficheiro compose como fonte deixa de fora uma unidade de nível superior desse ficheiro, e um ficheiro compose tem exatamente três kinds que uma entrada pode nomear — um service, um volume e um config, cada um identificado pela sua chave sob services:, volumes: ou configs: — e nenhum namespace. Uma entrada que nomeie qualquer outro kind, entre eles o Secret de um documento de chart ou uma network do compose, ou que tenha um namespace, não nomeia nada que o ficheiro possa deixar de fora, pelo que a renderização para em vez de tratar a entrada como uma que não correspondeu a nada. Os kinds são comparados exatamente, pelo que Service é recusado onde se pretende service. Cada entrada é verificada antes de qualquer coisa ser deixada de fora, e a nomeada é a primeira em erro, pela ordem em que as entradas foram escritas.
Mensagens emitidas. Ambas comunicam a condição de uma construção para a qual um fornecedor não tem expressão, e a frase própria do fornecedor nomeia a entrada e os kinds que aceita. Um campo cujo template leu um valor declarado sensível é mostrado como <redacted>:
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) 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: uma entrada omits (com o nome indicado) nomeia o kind indicado: o compose deixa de fora um serviço, um volume ou uma config, cada um nomeado pela sua chave sob services:, volumes: ou configs:, e nenhum outro kind)
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) 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: uma entrada omits (com o kind e o nome indicados) nomeia o namespace indicado, e um ficheiro compose não tem namespaces: o compose deixa de fora um serviço, um volume ou uma config, cada um nomeado pela sua chave sob services:, volumes: ou configs:, e nenhum outro kind; remover o namespace da entrada)
Como corrigir: nomear a unidade como o ficheiro compose o faz — kind: service, volume ou config, e como name: a sua chave sob essa secção — e retirar o namespace:. Consulte compose → Modo com fonte.
An omits entry names a namespace a CloudFormation template does not have (Uma entrada omits nomeia um namespace que um template CloudFormation não tem)
Uma entrada omits: numa Recipe ou numa FeatureRecipe que usa um template CloudFormation como fonte deixa de fora um recurso, nomeado pelo seu Type como o kind da entrada e pelo seu ID lógico como o name da entrada. Um template não tem namespaces, pelo que uma entrada que tenha um namespace não nomeia nada que um template possa deixar de fora, e a renderização para em vez de tratar a entrada como uma que não correspondeu a nada. Cada entrada é verificada antes de qualquer coisa ser deixada de fora, e a nomeada é a primeira que tem um namespace, pela ordem em que as entradas foram escritas.
Mensagem emitida. Comunica a condição de uma construção para a qual um fornecedor não tem expressão, e a frase própria do fornecedor nomeia a entrada e aquilo que este fornecedor deixa de fora. Um campo cujo template leu um valor declarado sensível é mostrado como <redacted>:
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) 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: uma entrada omits (com o kind e o nome indicados) nomeia o namespace indicado, e um template CloudFormation não tem namespaces: o cloudformation deixa de fora um recurso, nomeado pelo seu Type como o kind da entrada e pelo seu ID lógico sob Resources como o nome da entrada; remover o namespace da entrada)
A published port declares a transport compose cannot spell (Uma porta publicada declara um transporte que o compose não consegue escrever)
Uma porta publicada do compose tem o seu transporte como sufixo na entrada, e esse sufixo tem duas grafias. Uma porta que declare qualquer outro transporte não tem qualquer grafia no compose.
A renderização para em vez de descartar o sufixo, porque uma porta publicada que recorre silenciosamente ao transporte predefinido arranca a transportar tráfego que os seus clientes não conseguem alcançar — que é exatamente a falha que declarar um transporte existe para evitar, reintroduzida no momento da tradução.
Uma porta que não declara qualquer transporte não é afetada. É publicada sem sufixo, exatamente como seria uma porta que nunca teve um transporte.
Mensagem emitida. A condição nomeia o tipo de falha — um valor sem representação naquilo que o fornecedor emite — e a frase própria do fornecedor vem a seguir:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó indicado, aplicação das portas do serviço: o compose publica o transporte de uma porta como sufixo tcp ou udp; esta porta declara um transporte que o compose não consegue exprimir)
Como corrigir: para um destino compose, declarar o transporte da porta como um dos dois que o compose consegue escrever, ou deixá-lo por declarar e deixar a entrada ser publicada sem sufixo. Quando o transporte é o pretendido, renderizar essa fronteira através de um fornecedor cujo destino o consiga exprimir.
A resources quantity cannot be converted to a compose value (Uma quantidade de recursos não pode ser convertida num valor do compose)
As quantidades de processador e de memória de um contentor, e a sua contagem nvidia.com/gpu, são escritas na notação que o Kubernetes usa para recursos, e o compose transporta-as em unidades próprias — uma contagem de GPU passa a ser a contagem de uma reserva de dispositivos NVIDIA —, pelo que cada uma é lida como uma quantidade e convertida a partir do seu valor. Duas coisas impedem-no, e a mensagem diz qual encontrou: um valor que não é de todo uma quantidade, e uma quantidade para a qual o compose não tem forma exata — uma quantidade negativa, uma quantidade de memória que não é um número inteiro de bytes, uma quantidade de processador mais fina do que nove casas decimais de um núcleo, uma contagem de GPU que não é um número inteiro de dispositivos, ou uma quantidade acima da maior que o compose consegue conter. Um contentor cujo pedido e cujo limite nvidia.com/gpu peçam contagens diferentes também interrompe a renderização, porque o compose reserva uma única contagem para um serviço. A renderização para em vez de arredondar o valor ou emitir uma aproximação, porque um limite que silenciosamente não é o limite pedido é o tipo de diferença que ninguém procura até algo ser parado por o exceder.
Mensagens emitidas. Cada uma começa com a condição — um valor sem representação naquilo que o fornecedor emite —, depois nomeia o recurso, se o valor é um pedido ou um limite, o seu caminho no Workload e o valor. Um valor que não é uma quantidade é seguido daquilo que o impediu de o ser e da forma que uma quantidade assume:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó e no contentor indicados: compose: o pedido ou o limite indicado do recurso indicado, no caminho indicado: o valor indicado não é uma quantidade: com o motivo indicado; uma quantidade é um número como 2, 0.5 ou 1.5, com um sinal opcional e no máximo um de entre um expoente inteiro (1e3, 5E-2) ou um sufixo de unidade (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei): a quantidade de resources não pode ser convertida num valor deploy.resources do compose)
Uma quantidade que o compose não consegue representar é seguida do intervalo que o compose admite para esse recurso:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó e no contentor indicados: compose: o pedido ou o limite de memória indicado, no caminho indicado, é o valor indicado, uma quantidade que o compose não consegue representar exatamente; um valor de memória do compose é um número inteiro de bytes de 0 a 9223372036854775807: a quantidade de resources não pode ser convertida num valor deploy.resources do compose)
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó e no contentor indicados: compose: o pedido ou o limite de cpu indicado, no caminho indicado, é o valor indicado, uma quantidade que o compose não consegue representar exatamente; um valor cpus do compose é uma contagem de núcleos de 0 a 9223372036.854775807 com no máximo nove casas decimais: a quantidade de resources não pode ser convertida num valor deploy.resources do compose)
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó e no contentor indicados: compose: o pedido ou o limite nvidia.com/gpu indicado, no caminho indicado, é o valor indicado, uma quantidade que o compose não consegue representar exatamente; uma contagem de dispositivos do compose é um número inteiro de dispositivos de 0 a 9223372036854775807: a quantidade de resources não pode ser convertida num valor deploy.resources do compose)
Um pedido e um limite de GPU que peçam contagens diferentes nomeiam ambos os caminhos e ambas as contagens:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó e no contentor indicados: compose: o pedido nvidia.com/gpu no caminho indicado e o limite no caminho indicado pedem contagens diferentes (as indicadas); o compose reserva uma única contagem de dispositivos para um serviço, pelo que se deve escrever a mesma contagem em ambos ou apenas o limite: a quantidade de resources não pode ser convertida num valor deploy.resources do compose)
Quando o template do Workload lê um valor que um autor declarou sensível, nenhuma mensagem cita o valor que recusou, e as duas contagens são omitidas da mesma forma.
Como corrigir: quando o valor não é uma quantidade, escrevê-lo na forma descrita em Workload → Quantidades de recursos; um sufixo isolado como m é aquilo que um template deixa quando o valor que interpola está vazio, pelo que a entrada a corrigir é a que o template leu. Quando é uma quantidade que o compose não consegue representar, escrever uma quantidade dentro do intervalo que a mensagem indica — a memória como um número inteiro de bytes em qualquer unidade (1536Mi em vez de 1.5001Gi), o tempo de processador com no máximo nove casas decimais de um núcleo, e uma contagem de GPU como um número inteiro de dispositivos (1, e não 0.5 nem 500m). Quando um pedido e um limite de GPU divergem, escrever a mesma contagem em ambos, ou escrever apenas o limite, que é a contagem que o Kubernetes agenda para o mesmo Workload.
A resource quantity the helm provider emits is not a quantity (Uma quantidade de recurso que o fornecedor helm emite não é uma quantidade)
O fornecedor helm copia literalmente cada quantidade de recurso para os manifestos que emite — os valores resources.requests e resources.limits de cada contentor e contentor de inicialização, incluindo recursos estendidos, e o ephemeral.sizeLimit, o persistent.size e o persistentTemplate.size de cada volume — e verifica primeiro cada uma face à forma de uma quantidade, no Workload tal como os templates da Recipe o avaliaram. Um valor fora dessa forma interrompe a compilação aqui, onde de outro modo seria compilado sem erros e recusado pelo cluster quando o chart fosse instalado.
Mensagem emitida. Começa com a condição, depois nomeia o nó, o caminho do campo no Workload, o valor e aquilo que o impediu de ser uma quantidade, e indica a forma que uma quantidade assume:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó indicado: caminho indicado: o valor indicado não é uma quantidade: com o motivo indicado; uma quantidade é um número como 2, 0.5 ou 1.5, com um sinal opcional e no máximo um de entre um expoente inteiro (1e3, 5E-2) ou um sufixo de unidade (n, u, m, k, M, G, T, P, E, Ki, Mi, Gi, Ti, Pi, Ei))
Como corrigir: escrever o valor na forma descrita em Workload → Quantidades de recursos. Quando o campo é um template, o valor a corrigir é o que o template leu: um sufixo isolado como m ou Mi é aquilo que um template deixa quando o valor que interpola está vazio, e um parâmetro da Release chega ao campo exatamente como foi escrito.
A service type the helm provider cannot render (Um tipo de serviço que o fornecedor helm não consegue renderizar)
O fornecedor helm renderiza cada entrada services de um Workload como um Service do Kubernetes cujo tipo é o type da entrada. Uma entrada Loopback pede que as suas portas sejam alcançáveis a partir do próprio endereço de loopback do host e de mais nenhum lado, e um Service do Kubernetes não tem nenhum tipo que o faça: os endereços de nó em que um Service NodePort escuta são uma definição de todo o cluster, e não de um único Service. Assim, a compilação para na primeira entrada Loopback, pela ordem em que os serviços são declarados, antes de qualquer recurso ser escrito.
A compilação para em vez de renderizar a entrada como outro tipo, porque cada um dos tipos que um Service tem muda aquilo que a porta alcança: um Service ClusterIP perde o alcance publicado que a entrada pede, e um NodePort publica a porta em todos os endereços de nó que o cluster permite — a exposição mais ampla que a entrada existe para evitar.
Mensagem emitida. Começa com a condição, depois nomeia o nó, o caminho do serviço no Workload e o tipo:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó indicado: serviço indicado em services: o tipo «Loopback» publica as portas do serviço apenas no endereço de loopback do host, e um Service do Kubernetes não tem nenhum tipo que o faça; declarar ClusterIP para manter as portas dentro do cluster, ou NodePort ou LoadBalancer para as publicar fora dele)
Como corrigir: para um destino helm, declarar o tipo que diz até onde a porta deve chegar no cluster — ClusterIP para a manter dentro, NodePort ou LoadBalancer para a publicar. Uma entrada Loopback destina-se a um destino compose, que publica a porta em 127.0.0.1; consulte Workload → services.
A Kubernetes version the helm provider cannot render a chart for (Uma versão do Kubernetes para a qual o fornecedor helm não consegue renderizar um chart)
O fornecedor helm renderiza um chart a partir da fonte para a versão do Kubernetes que a anotação aggrega.ai/kubernetes-version nomeia num componente ou na sua fronteira, e lê o valor da forma como helm template --kube-version lê a sua opção. Um valor que essa opção recusaria — "one.two", "latest", um único número como "1", um número escrito com um zero à esquerda como "01.20" — não tem nenhuma versão que o chart possa ler como .Capabilities.KubeVersion, pelo que a compilação para antes de o chart ser renderizado.
A compilação para em vez de renderizar o chart para a versão predefinida, porque um chart lê a versão para escolher uma versão de API, um campo ou um mecanismo inteiro, e um chart renderizado para uma versão diferente da que foi nomeada emite a forma dessa outra versão — uma que o cluster em que é implementado pode não executar.
Um valor vazio não é recusado. É tratado como não definido, e o chart é renderizado para a predefinição: a versão para a qual o helm template original da mesma versão do helm renderiza.
Mensagem emitida. Começa com a condição, depois nomeia o nó e a fronteira em que está colocado, a anotação, o valor e aquilo que o impediu de ser uma versão, e indica a forma a escrever:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: no nó indicado, na fronteira indicada: anotação aggrega.ai/kubernetes-version: o valor indicado não é uma versão do Kubernetes para a qual seja possível renderizar um chart: com o motivo indicado; escrever a versão do cluster em que o chart é implementado, como «1.31» ou «v1.31.2», no componente ou na sua fronteira)
A mensagem nomeia tanto o nó como a sua fronteira porque o fornecedor lê em conjunto as anotações de um componente e as da sua fronteira, prevalecendo o valor próprio do componente, pelo que o valor pode ter sido escrito em qualquer um dos dois.
Como corrigir: escrever a versão do cluster em que o chart é implementado — uma versão principal e secundária como "1.31", ou uma completa como "v1.31.2" — no componente ou na sua fronteira, ou remover a anotação para renderizar para a predefinição. Consulte helm → A versão do Kubernetes para a qual um chart é renderizado.
A health probe cannot be turned into a compose healthcheck (Uma sonda de integridade não pode ser transformada num healthcheck do compose)
Uma sonda de integridade declarada torna-se um healthcheck do compose, e duas coisas podem impedi-lo.
Uma sonda que verifica um caminho por HTTP, num contentor que não publica nenhuma porta. A verificação é construída como um pedido a uma porta do contentor, pelo que, sem nenhuma porta declarada, não há endereço contra o qual a construir.
Uma sonda que não declara qualquer forma de verificação — nem um caminho, nem uma porta à qual se ligar, nem um comando a executar. Não há nada a transformar numa verificação. Trata-se de uma salvaguarda por trás do esquema, e não de uma forma que seja provável escrever: verifica-se se uma sonda tem uma das três antes de ela chegar aqui.
Mensagens emitidas. Ambas comunicam a mesma condição — algo que o fornecedor exige e que não conseguiu resolver para exatamente um valor — e a frase própria do fornecedor diz qual:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) compose: node "<node>" container "<container>": probe http: requires at least one container port; container declares none (compose: no nó e no contentor indicados: sonda http: exige pelo menos uma porta de contentor; o contentor não declara nenhuma)
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) compose: node "<node>" container "<container>": probe declares no shape (http/tcp/exec) (compose: no nó e no contentor indicados: a sonda não declara nenhuma forma (http/tcp/exec))
Como corrigir: declarar a porta contra a qual a verificação deve ser feita no mesmo contentor da sonda — uma sonda por HTTP lê a primeira porta do contentor, pelo que a porta tem de existir para que a verificação seja construída. Quando o contentor realmente não publica nada, verificá-lo de outra forma: uma sonda que executa um comando não precisa de porta. Para uma sonda sem nenhuma forma de verificação declarada, dar-lhe uma das três.
A configmap volume has no file behind it (Um volume configmap não tem nenhum ficheiro por trás)
Um volume que monta configuração é entregue pelo mecanismo próprio do compose para isso, referenciado por nome, e a entrada que contém o conteúdo provém de um ficheiro que a Recipe emite. Esta condição é aquilo que uma referência sem entrada correspondente comunica: o ficheiro não está lá, pelo que o ponto de montagem existiria sem nada por trás e o contentor arrancaria a ler um caminho vazio.
A verificação é executada sobre toda a saída montada em vez de por componente, e isso é deliberado: a referência e a entrada que contém o conteúdo chegam por vias diferentes e podem vir de componentes diferentes do mesmo grupo, pelo que a saída montada é o primeiro ponto em que ambas estão presentes. Uma verificação por componente recusaria uma referência cujo conteúdo outro componente do mesmo grupo fornece.
Cada referência não resolvida é comunicada, e não apenas a primeira, numa ordem estável, pelo que uma única compilação as nomeia todas.
Mensagem emitida. A condição vem primeiro, depois cada serviço, a referência que fez e onde é montada:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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: o serviço indicado referencia a config indicada, montada no caminho indicado; declarar cada uma como uma entrada configs: de nível superior a partir da entrada artifacts: da Recipe: um volume configmap exige um ficheiro emitido através da entrada artifacts: da Recipe; nenhum encontrado)
Como corrigir: emitir o ficheiro a partir da entrada artifacts: da Recipe com o nome que o volume referencia — os dois são associados por esse nome, pelo que uma divergência entre aquilo que o volume pede e aquilo que a Recipe emite é a causa comum. Quando o conteúdo devia vir de outro lado, o volume é o mecanismo errado para isso: um valor que pertence ao ambiente vai antes para lá.
What an omits entry left out is still named by the compose file (Aquilo que uma entrada omits deixou de fora ainda é nomeado pelo ficheiro compose)
Uma entrada omits: deixa de fora um serviço, um volume ou uma config de um ficheiro compose de origem, e o compose recusa um ficheiro que nomeie um que não declara. Assim, uma vez removidas as unidades das entradas, cada referência que o resto do ficheiro ainda faz a uma delas interrompe a renderização: um serviço nomeado por depends_on, links, volumes_from, extends, um valor de build.additional_contexts ou um modo de rede, IPC, PID ou UTS service:; um volume nomeado como origem de uma entrada volumes:; uma config nomeada por uma entrada configs: — lidos em cada serviço, nos hooks pre_start de cada serviço e em cada job. A lista completa, e os valores que apenas parecem referências, estão em compose → Modo com fonte.
A verificação lê o ficheiro próprio da Recipe ou da FeatureRecipe que declara a entrada, pelo que interrompe a renderização mesmo quando outro contribuidor para o mesmo ficheiro montado declara uma unidade com o nome da que foi deixada de fora. Cada referência é comunicada, e não apenas a primeira — os serviços por ordem de chave, depois os jobs, os hooks de cada serviço a seguir a ele —, pelo que uma única compilação as nomeia todas.
Mensagem emitida. A condição vem primeiro, depois cada entrada que faz referência, a unidade que nomeia e o campo em que a referência está:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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: aquilo que uma entrada omits deixou de fora ainda é nomeado pelo ficheiro: o serviço indicado nomeia a unidade do kind e do nome indicados no campo indicado; o compose recusa um ficheiro que nomeie um serviço, um volume ou uma config que não declara: deixar de fora também aquilo que o nomeia, alterar a referência através de valuesMapping, ou remover a entrada)
Uma unidade cujo nome de entrada foi construído a partir de um valor declarado sensível é mostrada como <redacted>.
Como corrigir: decidir qual das duas coisas se pretendia. Quando o serviço que faz referência ainda precisa da unidade, mantê-la: remover a entrada. Quando não precisa, alterar a referência através do valuesMapping: da Recipe — uma lista aí substitui a lista do ficheiro base, pelo que depends_on: [] esvazia uma — ou deixar de fora o serviço que faz referência com uma entrada própria.
What an omits entry left out is still named by a CloudFormation template (Aquilo que uma entrada omits deixou de fora ainda é nomeado por um template CloudFormation)
Uma entrada omits: deixa de fora um recurso de um template CloudFormation de origem, e o CloudFormation recusa um template que nomeie um recurso que não declara. Assim, uma vez removidos os recursos das entradas, cada referência que os templates restantes ainda fazem a um deles interrompe a renderização: um Ref, um Fn::GetAtt na sua forma de lista ou na sua forma de cadeia de caracteres com ponto, o DependsOn de um recurso, ou uma variável de um Fn::Sub — lidos em qualquer parte do corpo de cada recurso e de cada saída. A lista completa, e os valores que apenas parecem referências, estão em cloudformation → Deixar recursos de fora de um template de origem.
A verificação lê em conjunto os templates próprios da Recipe ou da FeatureRecipe que declara a entrada: uma referência a um ID lógico que outro desses templates ainda declara não é interrompida, enquanto uma a um recurso deixado de fora interrompe a renderização mesmo quando outro componente declara um recurso com esse ID lógico. Cada referência é comunicada, e não apenas a primeira — template a template pela ordem em que a fonte os contém, em cada template os seus recursos e depois as suas saídas por ordem de chave —, pelo que uma única compilação as nomeia todas.
Mensagem emitida. A condição vem primeiro, depois cada referência: o template em que está, o recurso que nomeia, como o nomeia e onde fica como caminho a partir da raiz do template:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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: aquilo que uma entrada omits deixou de fora ainda é nomeado pelos templates da fonte: o template indicado nomeia o recurso indicado (do tipo indicado) da forma indicada no caminho indicado; o CloudFormation recusa um template que nomeie um recurso que não declara: deixar de fora também aquilo que o nomeia, ou remover a entrada)
Quando os campos de uma entrada foram construídos a partir de um valor declarado sensível, o ID lógico e o tipo do seu recurso são mostrados como <redacted>, tal como qualquer passo do caminho que escreva esse ID lógico.
Como corrigir: decidir qual das duas coisas se pretendia. Quando o recurso que faz referência ainda precisa daquele que foi deixado de fora, mantê-lo: remover a entrada. Quando não precisa, deixar de fora também o recurso que faz referência, com uma entrada própria — um valor associado a um parâmetro substitui apenas uma referência a esse parâmetro, pelo que uma referência a um recurso não pode ser alterada dessa forma. Uma saída que nomeie o recurso não pode ser deixada de fora, pelo que um recurso que uma saída nomeie permanece.
A valuesMapping key names no parameter of a sourced CloudFormation template (Uma chave de valuesMapping não nomeia nenhum parâmetro de um template CloudFormation de origem)
Um template CloudFormation de origem recebe valores através dos Parameters que declara, e o valuesMapping da Recipe ou da FeatureRecipe que o usa como fonte escreve uma chave por cada parâmetro que preenche. Uma chave que não nomeie nenhum parâmetro que algum template da fonte declare não tem para onde ir, pelo que a renderização para em vez de a descartar — a falha que o próprio CloudFormation comunicaria para um parâmetro desconhecido, comunicada enquanto ainda cabe ao utilizador corrigi-la. Apenas um valuesMapping preenche parâmetros: os valores que nada mapeou nunca são lidos desta forma, pelo que os valores próprios de um componente ou de um anexo escritos para as suas outras entradas nunca se deparam com isto.
Mensagem emitida. A condição vem primeiro, depois cada chave que não nomeou nada e aquilo que cada template da fonte declara:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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: o valuesMapping da Recipe ou da FeatureRecipe escreve a chave indicada, e nenhum template da fonte declara um parâmetro com esse nome: o template indicado declara o parâmetro indicado, …; um template de origem recebe valores apenas através dos parâmetros que declara, pelo que se deve mudar o nome da chave para o do parâmetro a que se destina, ou removê-la do valuesMapping)
Another component references a CloudFormation parameter a sourced template’s binding filled (Outro componente referencia um parâmetro do CloudFormation que a associação de um template de origem preencheu)
Preencher o parâmetro de um template de origem através do valuesMapping da Recipe ou da FeatureRecipe da Feature anexada que o usa como fonte substitui cada referência a ele em cada template dessa fonte e remove a sua declaração. O conteúdo de outra parte da mesma stack montada — o fragmento ou o template de origem de outro componente, ou o fragmento do componente ao qual uma Feature está anexada — que ainda nomeie o parâmetro através de Ref, de uma variável de Fn::Sub ou do Fn::ValueOf de uma regra nomeia então algo que a stack já não declara, o que o CloudFormation recusa quando a stack é implementada, pelo que a montagem para. Um nome que algum componente da stack ainda declare, como parâmetro próprio ou como ID lógico de um recurso, é uma referência que a stack resolve e não é interrompido.
Mensagem emitida. A condição vem primeiro, depois cada referência: o componente e o template em que está, o parâmetro, e o componente cujo valuesMapping da Recipe ou da FeatureRecipe anexada o preencheu — uma Feature anexada a um componente é nomeada por esse componente, e uma anexada a uma fronteira pela identidade que os seus recursos têm como aggrega.ai/component-id, composta a partir do caminho da fronteira e do nome do anexo, como bfr--stack--aux:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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: um parâmetro que a associação de um template de origem preencheu ainda é referenciado de outra parte da stack montada: o template indicado do componente indicado referencia o parâmetro indicado, que o valuesMapping de uma Recipe ou FeatureRecipe que renderiza para o componente indicado associa; …; associar um parâmetro remove a sua declaração da fonte que o declara, e nenhum template na stack o declara já, pelo que a referência não nomeia nada que o CloudFormation consiga resolver: referenciar antes aquilo que o componente que faz a associação publica, declarar o parâmetro no template que o referencia, ou remover a chave do valuesMapping)
Como corrigir: quando o componente que faz referência precisa do valor, fazer com que o componente que o preenche o publique através de provides e referenciar isso; ou declarar o parâmetro no template que faz referência para que receba o seu próprio valor; ou remover a chave do valuesMapping, para que o parâmetro continue declarado e cada componente leia o valor passado quando a stack é implementada. Consulte cloudformation → Valores para os parâmetros de um template de origem.
A value bound to a CloudFormation parameter cannot take the parameter’s type (Um valor associado a um parâmetro do CloudFormation não pode assumir o tipo do parâmetro)
Um literal associado a um parâmetro é convertido da forma como o CloudFormation converte o mesmo valor passado para o Type desse parâmetro quando a stack é implementada. Quando não existe tal conversão, a renderização para: um valor que não é um número associado a um Number ou a um List<Number>, uma lista ou um mapeamento associado a um parâmetro que aceita um único valor, e qualquer literal associado a um parâmetro AWS::SSM::Parameter::Value<…>, cujo valor o CloudFormation lê do Parameter Store em vez do template. Uma lista associada a um parâmetro que o template nomeie como variável de Fn::Sub também interrompe a renderização, porque uma variável substitui uma única cadeia de caracteres.
Mensagem emitida. A condição vem primeiro, depois o parâmetro, o seu template e o seu tipo, e o motivo por que o valor não se adequa; nenhum valor é citado:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) cloudformation-provider: parameter "<parameter>" of template "<template>" is of type <type>, and <why the value does not fit> (cloudformation-provider: o parâmetro indicado do template indicado é do tipo indicado, e o valor não se adequa pelo motivo indicado)
Como corrigir: associar um valor do tipo do parâmetro — ou, para um tipo do Parameter Store, uma referência dinâmica {{resolve:ssm:…}} ou uma função intrínseca — ou deixar o parâmetro sem associação para um valor passado quando a stack é implementada.
A value bound to a CloudFormation parameter is one its constraints refuse (Um valor associado a um parâmetro do CloudFormation é um que as suas restrições recusam)
Um literal associado a um parâmetro é verificado face às restrições que o template declara para ele — AllowedValues, AllowedPattern, MinLength, MaxLength, MinValue e MaxValue —, a verificação que o CloudFormation faz a um valor passado quando a stack é implementada, antecipada para o momento da compilação para que preencher um parâmetro não remova nenhuma verificação que o template declarou. Uma função intrínseca e uma referência dinâmica ficam para o CloudFormation verificar, uma vez que o seu valor só existe quando a stack é implementada.
Mensagem emitida. A condição vem primeiro, depois o parâmetro, o seu template e a restrição; nenhum valor é citado:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: o valor associado ao parâmetro indicado do template indicado não satisfaz a sua restrição indicada, que o CloudFormation recusaria quando a stack fosse implementada; associar um valor que o parâmetro admita)
Como corrigir: associar um valor que a restrição admita; a própria declaração do parâmetro no template indica o que ele permite.
A secret bound to a CloudFormation parameter would be written into the template (Um segredo associado a um parâmetro do CloudFormation seria escrito no template)
Um valor associado a um parâmetro é escrito no template, onde qualquer pessoa que possa ler o template da stack o pode ler. A renderização para perante um literal associado a um parâmetro que o template declara NoEcho e, onde o valuesMapping da Recipe ou da FeatureRecipe lê um valor que um autor declarou sensível, perante cada literal que esse mapeamento associa, uma vez que nenhuma parte da sua saída pode ser reconduzida ao valor de onde veio. Uma referência dinâmica e uma função intrínseca são escritas tal como são dadas — incluindo o texto dentro de uma função intrínseca —, pelo que um valor sensível que o mapeamento insere numa string Fn::Sub chega ao template como esse texto, e só uma referência dinâmica mantém o próprio segredo fora dele.
Mensagem emitida. A condição vem primeiro, depois os parâmetros e o que associar em vez disso; nenhum valor é citado. Uma das seguintes:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: o parâmetro indicado do template indicado está declarado como NoEcho, e o valor associado a ele seria escrito no template tal como está; associar em vez disso uma referência dinâmica ({{resolve:secretsmanager:…}} ou {{resolve:ssm-secure:…}}) ou uma função intrínseca, ou deixar o parâmetro sem associação para um valor no momento da implementação)
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: o valuesMapping da Recipe ou da FeatureRecipe lê um valor declarado sensível, pelo que um literal que produz é recusado, e associar o parâmetro ou os parâmetros indicados, … escreveria um literal no template tal como está; …)
Como corrigir: guardar o segredo no Secrets Manager ou como string segura do Parameter Store e associar uma referência dinâmica que aponte para ele — {{resolve:secretsmanager:<secret>}} ou {{resolve:ssm-secure:<name>}} — em vez de o inserir no texto de uma função intrínseca, ou deixar o parâmetro sem associação para um valor passado quando a stack é implementada. Consulte cloudformation → Valores para os parâmetros de um template de origem.
A dynamic reference is bound where CloudFormation does not resolve it (Uma referência dinâmica está associada onde o CloudFormation não a resolve)
O CloudFormation resolve uma referência dinâmica nas propriedades de um recurso, mas não nos dados de utilizador do EC2 nem nos metadados AWS::CloudFormation::Init, e mostra os Outputs de um template a quem lê a stack. Assim, uma referência dinâmica associada a um parâmetro que qualquer template da fonte referencia numa propriedade UserData, nesses metadados ou nos seus Outputs interrompe a renderização em vez de chegar a um sítio onde ou não pode ser implementada ou fica exposta.
Mensagem emitida. A condição vem primeiro, depois o parâmetro, o template e o sítio onde esse template o referencia; nenhum valor é citado:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: o valor associado ao parâmetro indicado é uma referência dinâmica, e o template indicado referencia o parâmetro no sítio indicado, onde o CloudFormation não resolve uma referência dinâmica ou a mostra a quem lê a stack; associar em vez disso uma função intrínseca, ou deixar o parâmetro sem associação para um valor no momento da implementação)
Como corrigir: deixar o parâmetro sem associação e passar o seu valor quando a stack for implementada, ou associar uma função intrínseca que produza aquilo de que o template precisa nesse sítio.
A rule reads a bound CloudFormation parameter by name (Uma regra lê pelo nome um parâmetro do CloudFormation associado)
Fn::ValueOf nas Rules de um template nomeia um parâmetro pelo seu ID lógico em vez de através de Ref, e lê o valor passado para ele quando a stack é implementada. Associar o parâmetro remove a sua declaração de todos os templates da fonte, o que deixaria a regra — em qualquer um desses templates — sem nomear nada, pelo que a renderização para.
Mensagem emitida. A condição vem primeiro, depois a regra, o seu template e o parâmetro:
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) 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: a regra indicada do template indicado lê o parâmetro indicado através de Fn::ValueOf, que nomeia um parâmetro declarado pelo seu ID lógico, e associar o parâmetro remove a sua declaração da fonte; deixar o parâmetro sem associação para que a regra o possa ler no momento da implementação)
Como corrigir: remover a chave do parâmetro do valuesMapping, para que o parâmetro continue declarado e a regra leia o valor passado quando a stack é implementada.
The assembled CloudFormation stack cannot carry a transform (A stack do CloudFormation montada não consegue transportar uma transformação)
O Transform da stack montada é construído a partir do de cada componente, e uma transformação processa o template inteiro, pelo que uma transformação cujo efeito não se restringe ao conteúdo escrito para ela é recusada em vez de poder mudar a forma como o conteúdo de outro componente é implementado: AWS::CodeDeployBlueGreen e AWS::Include sempre, uma macro definida pela conta e AWS::ServiceCatalog ao lado de qualquer outro componente, AWS::LanguageExtensions ao lado do conteúdo serverless de outro componente, e AWS::Serverless-2016-10-31 onde os seus Globals alcançariam os recursos serverless de outro componente ou uma das suas fontes de eventos nomeia um recurso que outro componente declara. A tabela completa está em cloudformation → Secções de nível superior na stack montada.
Mensagem emitida. A condição vem primeiro, depois cada componente na stack, a transformação e os componentes que a declaram, e porque é que não pode ser transportada:
a plugin has no expression for a construct this build declares (um plugin não tem expressão para uma construção que esta compilação declara) cloudformation-provider: the assembled stack of component "<component>", … cannot carry the transform "<transform>", declared by component "<component>": <why> (cloudformation-provider: a stack montada do componente indicado, … não consegue transportar a transformação indicada, declarada pelo componente indicado: com o motivo indicado)
Como corrigir: colocar o componente que declara a transformação numa fronteira própria, para que a sua stack não contenha nada que a transformação possa mudar; ou, onde a mensagem nomeia conteúdo que outro componente declara, mover esse conteúdo para o componente que declara a transformação.
Two components order one pair of transforms oppositely (Dois componentes ordenam um mesmo par de transformações de forma oposta)
A stack montada executa as suas transformações numa única ordem, construída a partir da ordem própria de cada componente e da ordem documentada pelo CloudFormation. Onde duas ordens não podem valer ao mesmo tempo — dois componentes que listam um mesmo par de transformações ao contrário, ou um componente que lista AWS::Serverless-2016-10-31 antes de AWS::LanguageExtensions, que o CloudFormation documenta ao contrário —, não há uma única ordem a escrever, pelo que a renderização para.
Mensagem emitida. A condição vem primeiro, depois o par e quem o ordenou em cada sentido:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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: as transformações indicadas estão ordenadas nos dois sentidos — a primeira antes da segunda por quem é indicado, e a segunda antes da primeira por quem é indicado — e o Transform da stack montada executa-as numa única ordem; declará-las numa única ordem)
Como corrigir: declarar o par numa única ordem em cada componente que liste os dois, seguindo a ordem própria do CloudFormation onde este documente uma.
Two entries reach one stack output name (Duas entradas chegam a um mesmo nome de saída da stack)
Um nome de saída da stack só admite letras e dígitos, pelo que é construído a partir do que foi escrito codificando os caracteres que esse alfabeto não admite em vez de os descartar. Duas entradas escritas de forma distinta continuam, portanto, distintas, e esta interrupção é o que comunica o caso em que duas delas chegam, ainda assim, a um mesmo nome. A renderização para em vez de emitir uma única saída onde foram escritas duas entradas, o que descartaria silenciosamente uma delas.
Cada nome atrás do qual duas ou mais entradas se encontraram é comunicado, e cada entrada atrás de cada nome é nomeada, numa ordem estável — assim uma única compilação mostra a colisão inteira em vez de um só lado dela.
Mensagem emitida, que começa com a condição e continua com o detalhe próprio do fornecedor:
two things a plugin produced occupy one name in its output (duas coisas que um plugin produziu ocupam um mesmo nome na sua saída) 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: duas entradas que um autor escreveu chegam a um mesmo nome de Output da stack: as entradas indicadas que se encontraram chegam ao nome de Output indicado; um nome de Output é construído codificando o componente e a entrada nas letras e nos dígitos que um ID lógico admite, em vez de descartar o que este não admite, pelo que duas entradas que um autor escreveu distintas continuam distintas — mudar o nome de qualquer uma das duas pontas desbloqueia a compilação)
Como corrigir: mudar o nome de uma das entradas, ou de um dos componentes, para que as duas deixem de chegar a um mesmo nome — a mensagem nomeia os dois lados. O nome tem a pontuação e as maiúsculas e minúsculas que foram escritas, codificadas em vez de descartadas, pelo que uma diferença em qualquer uma delas se mantém nele e duas entradas escritas de forma diferente recebem nomes distintos.
A CloudFormation fragment writes one key twice (Um fragmento do CloudFormation escreve uma mesma chave duas vezes)
Um mapeamento contém um valor por chave, pelo que um fragmento que escreva a mesma chave duas vezes manteria o corpo que veio em último lugar e descartaria o outro. Onde o mapeamento é o bloco que contém os recursos ou as saídas, o corpo descartado é um recurso ou uma saída que foi escrito e não estaria no resultado. Em vez disso, a renderização para.
Os dois sítios onde a chave foi escrita são comunicados, porque uma chave escrita duas vezes é normalmente o resultado de duas edições pensadas como duas chaves diferentes — e o autor precisa dos dois para saber qual mudar.
Mensagem emitida, que começa com a condição e continua com o detalhe próprio do fornecedor:
two things a plugin produced occupy one name in its output (duas coisas que um plugin produziu ocupam um mesmo nome na sua saída) 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: uma chave de mapeamento é escrita mais de uma vez: a chave indicada é escrita na linha indicada e de novo na segunda linha indicada; um mapeamento contém um valor por chave, pelo que um dos dois corpos seria descartado — remover um, ou mudar o nome de um para que cada chave seja escrita uma única vez)
Como corrigir: abrir o fragmento nas duas linhas que a mensagem nomeia. Onde os dois corpos deviam ser uma só coisa, remover o que agora é redundante; onde deviam ser dois, mudar o nome de um para que cada um tenha a sua própria chave. O fragmento é um template, pelo que, onde uma chave é composta em vez de escrita literalmente, verificar o texto renderizado e não apenas a fonte.
A cross-boundary reference has no consuming stack to be written into (Uma referência entre fronteiras não tem nenhuma stack consumidora onde ser escrita)
Onde uma conexão de dependência passa entre duas saídas montadas separadamente, o lado consumidor é renderizado com um marcador de posição e a referência é escrita assim que os dois lados existem. Esta condição é o que acontece quando a saída montada do lado consumidor não contém nenhum template de stack: não há nenhum documento onde escrever a referência, pelo que o marcador de posição não pode ser substituído.
Mensagem emitida. A condição nomeia o tipo de falha, e a frase própria do fornecedor diz qual a entrada:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) cloudformation-provider: cross-boundary link resolve received no consumer stack template (cloudformation-provider: a resolução da ligação entre fronteiras não recebeu nenhum template de stack do consumidor)
Como corrigir: nada do que se escreve dentro do componente consumidor produz isto — é a forma daquilo que a sua fronteira montou. Verificar se o lado consumidor é de facto renderizado pelo fornecedor CloudFormation: uma conexão que passa para uma fronteira que monta outra coisa não tem nenhuma stack onde a referência possa cair, e a conexão pertence entre duas fronteiras que o mesmo fornecedor monta. Onde os dois lados deveriam ser CloudFormation, a fronteira consumidora não produziu nenhum template de stack, o que é uma questão para quem escreveu as Recipes que contribuem para ela.
A cross-boundary reference was spliced into a longer string (Uma referência entre fronteiras foi inserida numa string mais longa)
Uma referência cruzada do CloudFormation é um objeto e não texto, pelo que só pode substituir um valor por inteiro. Esta condição é o que comunica um marcador de posição encontrado dentro de uma string maior — um valor composto à volta dele, em vez de entregue como a totalidade daquilo que foi injetado. Não há nada pelo qual trocar o objeto, pelo que a renderização para em vez de emitir uma referência numa forma que o destino não consegue ler.
Mensagem emitida. A condição vem primeiro, depois o valor e a conexão pela qual chegou:
a plugin has no representation for a value it was given (um plugin não tem representação para um valor que recebeu) 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: o valor da ligação entre fronteiras está interpolado numa string maior; só uma injeção de um escalar inteiro pode transportar uma referência entre stacks: com a chave de saída indicada no socket indicado)
Como corrigir: entregar o valor por inteiro em vez de compor à volta dele. Onde o lado consumidor precisa do valor dentro de uma string mais longa — uma string de conexão, um URL —, construir essa composição no vocabulário próprio do destino a partir da referência, em vez de no template da Recipe antes de a referência existir. O mapeamento que injeta o valor é onde a inserção acontece, pelo que é essa a linha a mudar.
Two rendered resources land at one output file (Dois recursos renderizados vão parar a um mesmo ficheiro de saída)
Cada recurso renderizado é escrito num ficheiro cujo nome vem daquilo que o recurso é e de como se chama. Dois recursos que partilham essas duas coisas têm o mesmo nome de ficheiro, pelo que um ocuparia o lugar do outro e a renderização para em vez de emitir um único ficheiro onde foram renderizados dois recursos.
Dois recursos renderizados de forma idêntica não são uma colisão. Onde o conteúdo coincide byte a byte, manter um não perde nada e a renderização continua — pelo que um template incluído duas vezes com o mesmo resultado não é comunicado.
Mensagem emitida. A condição vem primeiro, depois os dois templates que os produziram e o ficheiro onde se encontraram:
two things a plugin produced occupy one name in its output (duas coisas que um plugin produziu ocupam um mesmo nome na sua saída) 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: no nó indicado: os recursos renderizados indicados, um e outro, derivam ambos a saída indicada com conteúdo diferente: dois recursos renderizados derivam o mesmo nome de ficheiro de saída com conteúdo diferente)
Como corrigir: dar aos dois recursos identidades distintas — o nome é o que normalmente difere, e o nome do ficheiro decorre dele. A mensagem nomeia os dois templates, pelo que convém abri-los e verificar o que cada um produz: dois templates que renderizam o mesmo recurso sob um mesmo nome significam muitas vezes que um deles é uma cópia mais antiga. Onde os dois são pretendidos, são dois recursos e cada um precisa de um nome próprio.
A synthesized StatefulSet has no single service to govern it (Um StatefulSet sintetizado não tem um único serviço que o governe)
Uma carga de trabalho que declara armazenamento por instância é renderizada como um StatefulSet, e um StatefulSet nomeia um serviço que o governa — aquele que dá a cada instância o seu endereço estável. Esse serviço é o que é declarado sem um endereço de cluster próprio. Duas formas param a renderização: nenhum declarado, pelo que não há nada a nomear; e mais de um, pelo que a questão de qual deles governa não tem resposta. Qualquer uma das duas produziria um StatefulSet que o destino rejeita, pelo que a renderização para em vez de emitir um.
Mensagens emitidas. Ambas comunicam a mesma condição — algo de que o fornecedor precisa e que não conseguiu resolver para exatamente um valor — e a frase própria do fornecedor diz qual das duas formas ocorreu. Cada uma é impressa sob uma moldura que nomeia o nó:
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) synthesized StatefulSet requires a headless governing Service (declare a service with type: Headless); none found: synthesized StatefulSet has no headless governing Service (o StatefulSet sintetizado exige um Service headless que o governe (declarar um serviço com type: Headless); nenhum encontrado: o StatefulSet sintetizado não tem nenhum Service headless que o governe)
a plugin could not resolve something it requires to exactly one value (um plugin não conseguiu resolver para exatamente um valor algo de que precisa) 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 (o StatefulSet sintetizado declara mais de um Service headless; o Service que o governa é ambíguo (declarar exatamente um serviço type: Headless): o StatefulSet sintetizado tem mais de um Service headless)
Como corrigir: declarar exatamente um serviço do tipo headless na carga de trabalho. Onde nenhum está declarado, acrescentá-lo — uma carga de trabalho com armazenamento por instância precisa de um, e é ele que dá a cada instância um endereço que fica com ela. Onde está declarado mais de um, manter aquele que deve governar e dar aos outros um tipo comum, ou removê-los; um segundo serviço headless é normalmente um que não precisava de ser headless.
A plugin reported a failure it did not classify (Um plugin comunicou uma falha que não classificou)
Um plugin que para uma compilação comunica duas coisas: uma frase própria que diz o que aconteceu, e que tipo de falha essa frase nomeia. Os tipos são um pequeno conjunto que o compilador declara — uma construção sem expressão, uma entrada que não pôde ser resolvida para um único valor, duas coisas produzidas que pretendem um mesmo nome, um valor sem representação — e esta condição é a que um plugin escolhe quando a sua falha não se enquadra em nenhum deles.
É um último recurso e não um destino. Um plugin que recorre a ela onde um dos outros tipos se enquadra está a dizer menos do que sabe, e a formulação diz claramente que o plugin prescindiu de classificar, e não que algo simplesmente correu mal — assim, um último recurso usado em excesso é reconhecível em vez de indistinguível de uma comunicação correta.
Mensagem emitida. A condição vem primeiro e a frase própria do plugin vem a seguir:
a plugin reported a failure that none of the declared kinds names (um plugin comunicou uma falha que nenhum dos tipos declarados nomeia) <the plugin's own sentence>
Como corrigir: ler a frase própria do plugin, que é onde está tudo o que é específico da compilação em causa. A condição em si diz apenas que o plugin não tinha um tipo para ela. Onde o plugin é próprio, escolher o tipo que a falha realmente é; onde não é, a frase é o que se deve citar a quem o publica.
A plugin named a condition the socket does not declare (Um plugin nomeou uma condição que o socket não declara)
Um plugin comunica uma condição que este compilador declara em vez de inventar um número próprio, pelo que o identificador que chega ao utilizador é sempre um a que aggrega explain dá resposta. Esta interrupção é o que produz uma comunicação que nomeie qualquer outra coisa: um número sob o qual nada está registado, um número que foi retirado, um código curto escrito de forma diferente do registo para o qual resolve, ou um par de identificadores que nomeiam duas condições diferentes.
Para em vez de descartar a comunicação em silêncio. Descartar os identificadores e deixar valer a condição genérica de falha de plugin produziria uma compilação exatamente igual à de um plugin que não nomeou condição nenhuma, pelo que quem tem de a corrigir nunca saberia que havia algo a corrigir. Comunicar em vez disso o número oferecido entregaria um identificador que não resolve para nada.
A compilação continua a receber o que a parou. A interrupção cita o número problemático, diz porque não resolve para nenhuma condição, nomeia as condições genéricas a que um plugin recorre quando não tem melhor identidade, e transmite inalterada a frase própria do plugin.
Mensagem emitida:
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: o plugin convidado nomeou uma condição que o socket não declara: o convidado nomeou o valor indicado, com o motivo indicado pelo qual não resolve para nenhuma condição; um plugin nomeia uma condição que este compilador declara, e recorre a uma das condições genéricas indicadas, com os seus códigos, quando não tem uma melhor: seguido da frase própria do plugin)
Como corrigir: nada nos ficheiros de entidade causa isto — é a comunicação do plugin que está errada, e a falha que estava a comunicar é real. Agir com base na frase própria do plugin, que é a última parte da mensagem. Onde o plugin é próprio, comunicar uma condição que este compilador declara — um dos tipos genéricos que a mensagem lista, onde a falha não se enquadra em nenhuma das condições mais específicas; onde o plugin não é próprio, citar o número problemático a quem o publica.
A source artifact is cached without a workspace root to anchor it (Um artefacto de origem é guardado em cache sem uma raiz do espaço de trabalho a que o ancorar)
Um artefacto de origem adquirido é guardado num slot sob a cache de artefactos do espaço de trabalho, e o caminho para esse slot é construído a partir da raiz do espaço de trabalho para fora. Esta condição comunica que a raiz chega vazia, o que deixaria relativo o caminho do slot — resolvido em relação a qualquer diretório em que o processo se encontre quando os bytes são escritos, e colocando a cache num local que ninguém escolheu.
É recusada em vez de resolvida, porque um slot escrito no sítio errado é pior do que nenhum slot: as leituras posteriores procuram no certo, não encontram nada e voltam a adquirir, pelo que o que se veria é uma cache que parece nunca conter nada, e nada mais que aponte a razão.
Mensagem emitida. Abre com a frase própria da condição, e segue-se o que identifica o artefacto:
cacheslot: empty workspaceRoot (kind=<kind> url=<url> chart=<chart> version=<version>) (cacheslot: workspaceRoot vazio (com kind, url, chart e version indicados))
Como corrigir: nada nos ficheiros de entidade causa isto e nenhuma alteração ao que se escreve o resolve — a raiz do espaço de trabalho é fornecida por aquilo que estiver a conduzir a compilação, e não escrita num catálogo. Executar a compilação a partir do interior do espaço de trabalho, para que a raiz seja descoberta em vez de passada como nada. Onde o compilador é conduzido a partir de software próprio, passar explicitamente a raiz do espaço de trabalho; um chamador que queira realmente a cache relativa ao diretório atual passa um único ponto, que é aceite e o diz deliberadamente.
A value would place a cached file outside the cache (Um valor colocaria um ficheiro em cache fora da cache)
Uma entidade em cache e um artefacto de origem em cache vivem cada um num slot que a cache nomeia para ele, e esse slot é composto a partir de valores: a referência da entidade e a versão para a qual resolveu, ou o tipo, url, chart, module_subdir, a versão e o digest de uma fonte. Cada valor nomeia uma posição na estrutura. Esta condição comunica um valor que moveria o que é escrito para ele para um sítio diferente da posição que nomeia — ao lado de outro slot, ou totalmente para fora da cache — e recusa-o antes de qualquer coisa ser aí escrita ou lida.
A maioria desses valores chega de um sítio que a cache não controla: um corpo servido por um registo, uma entrada relida do disco, uma coordenada escrita pelo autor de uma Recipe ou de uma FeatureRecipe. Uma versão que é um caminho em vez de uma versão, um caminho url ou um module_subdir que sobe acima do seu lugar, e uma referência que resolve para um diretório de pontos são, cada um, recusados aqui. Um valor que nomeia um único diretório — e um caminho url ou um module_subdir que fica no seu lugar ou abaixo dele — não é alterado.
Um module_subdir que sobe é recusado antes de qualquer coisa ser obtida. Para uma fonte git-repository, o mesmo valor nomeia também o diretório do repositório que o pull arquiva, e um que suba acima do repositório levaria o pull a ler os ficheiros ao lado do seu checkout. Por isso o pull avalia module_subdir antes de obter o repositório, e recusa um valor que sobe com esta condição, citando-o sob a sua chave: nada é obtido, e nada ao lado do checkout é lido. Uma barra invertida nele é lida como separador, tal como a lê um caminho do Windows, pelo que ..\shared é recusado em todas as máquinas em vez de ser lido de ao lado do checkout numa delas; um separador no início ou no fim do valor é descartado, pelo que /charts/app nomeia charts/app.
Mensagem emitida. Abre com a frase própria da condição, depois o valor tal como foi escrito sob a chave com que foi escrito, e a solução:
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 (um valor a partir do qual é construído um local da cache colocaria ficheiros em cache fora do sítio que nomeia na cache (a versão indicada para a entidade indicada). uma versão, um nome, um tipo ou um host nomeia um único diretório da cache, pelo que não contém nem barra nem barra invertida e não é nem um ponto simples nem um ponto duplo; um caminho de URL ou um subdiretório de módulo pode nomear diretórios abaixo do seu lugar, mas não pode subir acima dele. Corrigir o valor onde foi escrito, ou, onde um registo o serviu, pedir a quem o publica que publique uma versão que tenha um bem formado)
Como corrigir: onde o valor foi escrito pelo próprio utilizador — source.version, url ou module_subdir de uma Recipe ou de uma FeatureRecipe —, corrigi-lo para que nomeie um único diretório, ou um caminho que fique dentro do seu lugar; a mensagem cita o valor e a chave de onde foi lido. Onde um registo o serviu, a entidade publicada tem uma versão ou uma coordenada que não o é, o que nenhuma alteração do utilizador consegue corrigir: a mensagem nomeia o que foi obtido, e a solução cabe a quem a publica.
A path the operation writes leads through a link out of the directory it must stay inside (Um caminho que a operação escreve conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar)
Várias operações escrevem ou removem ficheiros próprios, em locais que determinam por si mesmas em vez de locais indicados pelo utilizador: o diretório de saída de uma compilação e cada ficheiro que aí escreve, e o diretório .trace que uma compilação com rastreio substitui; o ficheiro de bloqueio de uma Release, e o registo de confiança de plugins ao lado dele, que um pull escreve; o ficheiro entity.lock junto a uma entidade, que aggrega pin escreve, e que um pull que fixa fontes escreve junto a cada entidade que fixa; o ficheiro .aggrega-config.yaml do espaço de trabalho, quando um comando escreve a configuração do espaço de trabalho; a cache de artefactos e cada uma das suas subárvores, que um pull preenche e que aggrega cache clear e aggrega cache prune esvaziam; os bundles de assinatura que um pull guarda nessa cache para cada artefacto cuja assinatura verificou; os rascunhos que aggrega import escreve; as entidades Plugin que aggrega plugin gen-catalog escreve sob o seu diretório de saída; e o marcador .aggrega/active-release que o servidor de linguagem do editor escreve quando é registada uma Release predefinida, e o diretório .aggrega que o contém. O mesmo se aplica qualquer que seja a superfície que iniciou a operação — a linha de comandos, o servidor de linguagem do editor ou as ferramentas de um assistente. A fronteira do espaço de trabalho enuncia a regra que aqui se aplica, e os caminhos que saem do espaço de trabalho de propósito.
Cada um desses locais tem um diretório dentro do qual tem de ficar, e qual é depende do diretório sob o qual a operação o compõe:
O espaço de trabalho, para tudo o que é composto dentro dele. É o caso habitual, e aplica-se também a um diretório indicado pelo utilizador que fica dentro do espaço de trabalho. dist e .trace de uma compilação são sempre compostos aqui, sob a raiz do espaço de trabalho, qualquer que seja a pasta a partir da qual a compilação é executada, tal como os rascunhos de uma importação que não indica nenhum diretório de saída.
Um diretório indicado pelo utilizador que fica fora do espaço de trabalho, para tudo o que é composto abaixo dele: o diretório de saída passado a aggrega plugin gen-catalog ou a aggrega import; o diretório de uma Release indicada pelo utilizador, ou pela configuração do espaço de trabalho, que fica fora do espaço de trabalho, para o ficheiro de bloqueio e o registo de confiança ao lado dela; e o diretório de uma entidade indicada a aggrega pin, ou um diretório de catálogo indicado com --catalog ou que a configuração lista em catalog_dirs, para o ficheiro entity.lock junto a cada entidade aí. O próprio diretório é usado tal como foi indicado — num que seja uma ligação, a escrita passa através dela, para onde aponta — e o que é escrito abaixo dele fica dentro dele.
O próprio diretório da cache de artefactos, para tudo o que é escrito na cache abaixo dele e tudo o que aggrega cache clear e aggrega cache prune aí removem — tanto o .aggrega/cache predefinido como um artifact_cache_dir que a configuração escreve subindo para fora da raiz do espaço de trabalho (../shared-cache). Um dos diretórios próprios da cache, ou um ficheiro nela, que seja uma ligação que conduz para fora do diretório da cache é recusado mesmo onde conduz a outro lado dentro do espaço de trabalho, para que nada do que é escrito na cache, e nada do que um clear ou um prune remove, vá parar a um ficheiro fora dela. Onde fica o próprio diretório da cache é avaliado primeiro: um escrito dentro da raiz do espaço de trabalho é seguido para onde quer que conduza dentro do espaço de trabalho e recusado, sujeito ao espaço de trabalho, onde conduz para fora dele; um escrito subindo para fora da raiz do espaço de trabalho é usado tal como foi indicado, com a escrita a passar através dele até onde aponta, se for uma ligação.
Cada um desses locais é verificado antes de qualquer coisa ser aí escrita ou removida. A parte mais profunda do caminho que existe, com cada ligação simbólica pelo caminho seguida, tem de ser o diretório dentro do qual tem de ficar ou situar-se abaixo dele. Uma ligação em qualquer ponto do caminho que conduza para fora desse diretório — um dist ligado a um diretório noutro lado, um ficheiro de bloqueio ligado a um ficheiro noutro projeto, um .aggrega/cache ligado a um diretório partilhado com outro trabalho, um diretório sob um diretório de saída do gen-catalog ligado a outro lado — faria a escrita ou a remoção ir parar fora, pelo que a operação para em vez disso, e esse caminho fica exatamente como estava. Isto importa sobretudo para uma compilação: esvaziar e reescrever um diretório de saída que é uma ligação apagaria e reescreveria, caso contrário, um diretório noutro lado da máquina.
Uma ligação que não conduz a lado nenhum é tratada como aquilo que é — não algo que existe — pelo que é verificado o diretório que a contém. Onde uma ligação destas está mesmo no fim de um caminho que a operação está prestes a criar, o ficheiro seria criado onde a ligação aponta, pelo que o local para onde aponta é também verificado. Uma ligação que aponta para algum lado dentro do diretório dentro do qual o caminho tem de ficar é seguida como habitualmente.
Mensagem emitida. Abre com a frase própria da condição, depois o caminho que a operação estava prestes a escrever ou remover — writing ou removing diz qual — o diretório dentro do qual tem de ficar, a ligação que encontra pelo caminho e o local para onde essa ligação conduz, e depois a solução. Uma compilação cujo dist é uma ligação que conduz para fora do espaço de trabalho é parada na primeira coisa em que tocaria, o esvaziamento da saída 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 (um caminho que esta operação escreve ou elimina conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar (remoção do caminho indicado, que tem de ficar dentro do espaço de trabalho indicado; a ligação indicada conduz ao destino indicado). nada foi escrito nesse caminho nem removido dele. Remover a ligação, ou fazê-la conduzir a um local dentro do espaço de trabalho indicado, e executar novamente a operação)
O diagnóstico não tem categoria: o que está errado é a disposição no disco, e não qualquer documento escrito pelo utilizador.
Como corrigir: remover a ligação que a mensagem nomeia e executar novamente a operação, para que crie um diretório ou um ficheiro real nesse local; ou fazer a ligação conduzir a algum lado dentro do diretório que a mensagem nomeia, onde é seguida. Nada nos ficheiros de entidade causa isto e nenhuma alteração ao que se escreve o resolve.
A name the operation writes holds a part Windows cannot hold (Um nome que a operação escreve contém uma parte que o Windows não consegue conter)
No Windows, alguns nomes não chegam a um ficheiro tal como estão escritos. Um nome que o Windows reserva para um dispositivo — CON, PRN, AUX, NUL, CONIN$, CONOUT$, de COM0 a COM9 e de LPT0 a LPT9, e os nomes COM e LPT escritos com um um, um dois ou um três em expoente — nomeia o dispositivo e não um ficheiro, em qualquer combinação de maiúsculas e minúsculas e seja qual for a extensão que se lhe siga, pelo que nul, Aux.yaml e com1.txt são todos dispositivos. E uma parte de um caminho que termine num ponto ou num espaço é uma parte que o Windows pode cortar em vez de a manter tal como está escrita. Escrever um nome destes colocaria os seus bytes noutro sítio que não o ficheiro que nomeia.
Assim, quando uma operação está prestes a escrever, sob um diretório numa máquina Windows, um nome que não escolheu ela própria, um nome que contenha uma parte destas é recusado antes de qualquer coisa ser escrita: uma entrada do arquivo que um artefacto de origem ou uma entidade do catálogo traz, quando a cache dispõe o arquivo para ser lido; um ficheiro que uma compilação renderiza no seu diretório de saída; um rascunho que um importador devolve a aggrega import, tanto numa execução de teste como numa escrita; e o documento que aggrega edit-document volta a escrever, seja qual for a superfície que pediu a edição. Cada parte do nome é avaliada, com uma barra invertida lida como separador, tal como o Windows a lê — assim, aux/x.yaml é recusado pelo seu diretório aux, report. pelo seu ponto final e .. \evil.yaml pela sua primeira parte, dois caracteres de ponto e um espaço. Um conjunto recusado por um único nome não escreve nenhum dos outros: um arquivo não é disposto, a saída de uma compilação não é limpa nem escrita, e nenhum rascunho chega ao disco.
No Linux e no macOS, os mesmos nomes são escritos tal como são nomeados, e esta condição nunca é acionada. Um nome que sobe para fora do diretório sob o qual é escrito é uma falha diferente, recusada em todas as plataformas com a mensagem própria dessa operação antes de esta condição ser consultada.
Mensagem emitida. Abre com a frase própria da condição, depois o nome, a parte que o Windows não consegue conter e o diretório sob o qual o nome ia ser escrito, depois a correção:
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 (um nome que esta operação escreve contém um segmento de caminho que o Windows não consegue conter tal como está escrito (o nome, o seu segmento e o diretório indicados). Não foi escrito. O Windows reserva nomes de dispositivo como CON, PRN, AUX, NUL, COM1 e LPT1, em qualquer combinação de maiúsculas e minúsculas e seja qual for a extensão que se siga, e não mantém tal como está escrito um segmento que termine num ponto ou num espaço; mudar o nome desse segmento onde o nome é produzido)
O diagnóstico não tem nenhuma categoria: o nome vem daquilo que o produziu — quem publica um arquivo, uma Recipe ou uma biblioteca, um importador, o caminho que uma edição nomeia — e não de um único documento ao qual o compilador atribua a falha.
Como corrigir: mudar o nome da parte que a mensagem nomeia no sítio de onde o nome vem. Para uma entrada de arquivo, trata-se do artefacto de origem ou da entidade publicados, que só quem os publica pode alterar. Para um ficheiro renderizado, é o nome de saída que uma Recipe ou uma ArtifactLibrary lhe dá; para um rascunho, o importador que o nomeou; para uma edição, o caminho do documento. Nada na máquina Windows torna o nome utilizável tal como está escrito.
Condições que não interrompem uma compilação
Todas as condições acima interrompem uma compilação. Algumas condições têm um código curto e uma mensagem próprios sem nunca interromperem nenhuma, e estão catalogadas aqui para que um código que se tenha em mãos se resolva sempre em algo, seja qual for a página de onde se chegou.
Dividem-se em quatro tipos, e vale a pena conhecer a diferença antes de ir à procura de uma correção.
Um aviso. A compilação comunica-o e prossegue, e a saída renderizada é a mesma quer se aja sobre ele, quer não. Cada um é explicado na íntegra em warnings.md — o que o aciona, em que ponto da compilação é lido, o que imprime e o que fazer a esse respeito — e as entradas abaixo indicam qual secção, em vez de o repetirem aqui.
Uma condição que o editor absorve. É respondida pela própria integração do editor e não chega nem à saída de uma compilação nem a um diagnóstico.
Uma salvaguarda por trás de uma recusa anterior. A regra que protege é aplicada antes dela por uma condição que de facto interrompe, pelo que uma compilação encontra primeiro a anterior.
Uma recusa num comando que não é uma compilação. É uma interrupção definitiva com uma correção real — termina o comando que a encontrou, e nada é publicado, escrito ou alterado — mas nenhuma fase da compilação a alcança, pelo que nenhuma compilação a comunica. Publicar ou assinar um artefacto, fixar as entradas de uma entidade, adicionar um registo, editar um documento, transformar a descrição de uma origem externa em ficheiros de autoria em rascunho e verificar um catálogo inteiro — quanto à correção ou face às convenções de publicação — são os sítios onde se encontram, e cada entrada indica a que comando pertence e quem detém a correção.
An annotation binding declares one path in both pillar lists (Uma associação de anotação declara um mesmo caminho em ambas as listas de pilares)
Um aviso. Uma associação de anotação do Manifest nomeia o mesmo caminho com pontos tanto na sua lista maps.infra como na sua lista maps.values. Declarar a sobreposição é legal e o compilador não a fiscaliza: o critério de desempate do encaminhamento envia de forma determinística o caminho por infra, o que deixa o lado values desse caminho inalcançável a partir do Aggregate.
A sua mensagem começa assim:
annotation binding declares one path in both pillar lists (uma associação de anotação declara um mesmo caminho em ambas as listas de pilares)
É o que avisa antes de uma compilação chegar à interrupção descrita acima em «An annotation routes through a pillar its authoring side may not use (Uma anotação é encaminhada por um pilar que o seu lado de autoria não pode usar)» — o aviso é a superfície antecipada, essa interrupção é a que impõe a regra. O lint é explicado em «Binding-map-overlap lint (Lint de sobreposição de mapas da associação)» em warnings.md.
An attachment name is one edit from a declared slot (Um nome de anexo está a uma edição de distância de um slot declarado)
Um aviso. Um componente anexa uma Feature sob um nome que não é um dos slots declarados do seu tipo, mas que está a uma única edição de um deles — a estrutura que uma gralha no nome de um slot assume. Um anexo sob um nome que nenhum slot declara é legal, pelo que nada é interrompido; o que o aviso nomeia é a consequência, ou seja, que o anexo é um anexo livre e não o preenchimento do slot pretendido, e que o slot fica vazio. Numa ligação, a mesma gralha não é legal e provoca, em vez disso, uma interrupção, que nomeia o slot próximo; ver «A connection carries an attachment under a name its socket declares no slot for (Uma ligação traz um anexo sob um nome para o qual o seu socket não declara nenhum slot)». Quando a Feature do anexo satisfaz o selector: do slot próximo, o aviso não é levantado: esse emparelhamento é avaliado pela interrupção descrita em «An attachment written under another name fits a slot its component leaves empty (Um anexo escrito sob outro nome encaixa num slot que o seu componente deixa vazio)», que o comunica quando o slot fica vazio.
A sua mensagem começa assim:
attachment name is a near miss for a declared slot (o nome do anexo é uma quase correspondência com um slot declarado)
Explicado em «Attachment-slot near-miss lint (Lint de quase correspondência de slots de anexo)» em warnings.md, com o limiar de emparelhamento e aquilo que deliberadamente não deteta.
A uses: socket name is one edit from a declared socket (Um nome de socket está a uma edição de distância de um socket declarado)
Um aviso. O próprio bloco uses: de um componente nomeia um socket que o seu tipo não declara, mas que está a uma única edição de um deles. Um programador é dono da topologia que o Aggregate declara e pode nomear um socket que o catálogo não previu, pelo que um nome de socket que o tipo não declara é legal nessa superfície e nada é interrompido. O que o aviso nomeia é a consequência: o nome mal escrito traça uma ligação ad hoc própria, sem seletor nem contrato por aresta, enquanto o socket pretendido fica por cablar.
A sua mensagem começa assim:
uses socket name is a near miss for a declared socket (o nome do socket uses é uma quase correspondência com um socket declarado)
Explicado em «Uses-socket near-miss lint (Lint de quase correspondência de sockets uses)» em warnings.md. As duas superfícies vizinhas em que um nome de socket ausente do usesSchema da entidade proprietária provoca de facto uma interrupção são tratadas acima em «uses: socket not declared in the owning entity’s usesSchema (Socket não declarado no esquema de sockets da entidade proprietária)».
A Recipe publishes a provides key its Component does not declare (Uma Recipe publica uma chave que o seu Component não declara)
Um aviso. A Recipe associada a um componente publica sob provides: uma chave que o tipo do componente não declara no seu contrato spec.schema.provides:. Publicar mais do que o Component declara é legal e continua a sê-lo — o contrato exige o subconjunto e permite o superconjunto. O que o aviso nomeia é uma consequência invisível de ambos os lados: um consumidor que lê através de uma aresta uses: vê o contrato declarado do destino, e não aquilo que a sua Recipe emita, pelo que uma chave não declarada não é entregue e um template consumidor que a leia é renderizado vazio.
A sua mensagem começa assim:
Recipe publishes a provides key its Component does not declare (a Recipe publica uma chave provides que o seu Component não declara)
O caso oposto não é um aviso: um Component que declara uma chave que a sua Recipe não publica deixa o contrato por cumprir e provoca uma interrupção. Explicado em «Undeclared-provides-key lint (Lint de chaves provides não declaradas)» em warnings.md.
A declared parameter is read by nothing (Um parâmetro declarado não é lido por nada)
Um aviso. Um Aggregate declara uma entrada sob spec.parameters: e nenhuma referência {{ .parameters.<key> }} no próprio texto desse Aggregate a lê, pelo que, seja o que for que uma Release forneça para ela, a saída renderizada é a mesma. O compilador não fiscaliza que ajustes um autor expõe, e um parâmetro pode legitimamente ser declarado antes da referência que o irá ler, pelo que isto avisa em vez de interromper.
A sua mensagem começa assim:
declared parameter is read by no reference in the Aggregate (o parâmetro declarado não é lido por nenhuma referência no Aggregate)
Explicado em «Unread declared-parameter warnings (Avisos de parâmetros declarados não lidos)» em warnings.md, incluindo porque é que um valor predefinido não é uma isenção e que referências a leitura consegue e não consegue ver.
A provider binding names a capability no plugin the build reads serves (Uma associação de fornecedor nomeia uma capacidade que nenhum plugin lido pela compilação serve)
Um aviso. Uma entrada plugins.providers nomeia uma capacidade e nenhum plugin, e nenhum dos plugins de fornecedor que a compilação lê — nos diretórios do catálogo, dentro do compilador ou entre os que o ficheiro de bloqueio regista — serve essa capacidade. Essa é a estrutura que uma capacidade mal escrita assume, e uma entrada destas não é lida por nada: uma associação só é consultada quando uma Recipe pede a sua capacidade, e uma que não nomeie nenhum plugin não seleciona nada que a resolução da capacidade não selecionasse sem ela.
Avisa em vez de interromper porque a compilação não pode ter a certeza. As associações são escritas uma vez para todo o espaço de trabalho, enquanto uma compilação é de uma única Release, pelo que o plugin que serve a capacidade pode ser um que só outra Release lê. A entrada que nomeia um plugin é avaliada de outra forma, e interrompe onde está certamente errada — ver acima «A plugins.providers binding names a plugin that does not serve the capability (Uma associação nomeia um plugin que não serve a capacidade)».
A sua mensagem começa assim:
plugins.providers entry names a capability no provider-rendering plugin the build reads serves (a entrada plugins.providers nomeia uma capacidade que nenhum plugin de renderização de fornecedores lido pela compilação serve)
e continua com a capacidade, e com uma capacidade servida a uma edição de distância, quando existe uma. Explicado em «Provider-binding unserved-capability warning (Aviso de capacidade não servida de uma associação de fornecedor)» em warnings.md.
An editor position falls outside the document (Uma posição do editor fica fora do documento)
Uma condição que o editor absorve. As funcionalidades do editor que dependem de onde está o cursor — ir para a definição, hover, conclusão automática — localizam primeiro o cursor dentro da estrutura analisada do documento. Esta condição é o que esse passo comunica quando a posição aponta para uma linha que o documento não tem, o que acontece de forma transitória enquanto uma edição está em curso e a posição que o editor enviou foi medida face a um texto que o documento já deixou para trás.
A sua mensagem diz:
position out of range (posição fora do intervalo)
Não chega a nenhuma compilação nem a nenhum diagnóstico. Todas as funcionalidades que a podem encontrar respondem sem resultado em vez de apresentar um erro, que é o comportamento que o protocolo do editor pede: um pedido a que não se pode responder não devolve nada, e o editor volta a perguntar após a tecla seguinte.
Não há nada a corrigir nos ficheiros, e nada aparece numa compilação. Uma funcionalidade que fica sem responder em vez de recuperar na edição seguinte merece ser comunicada como defeito.
The schema-merge step’s own input guard (A salvaguarda de entrada própria do passo de fusão de esquemas)
Uma salvaguarda que uma compilação não alcança. Quando um Component ou uma Feature estende outro e ambos declaram esquemas, esses esquemas são combinados num só. A biblioteca que faz a combinação recusa uma entrada que não consegue fundir estruturalmente:
merger: invalid merge input (merger: entrada de fusão inválida)
Pertence ao passo de combinação, que uma compilação de facto alcança sempre que uma entidade que estende outra e a sua base declaram ambas esquemas. Aquilo contra que protege é receber uma cadeia vazia, ou uma entrada da cadeia cujo esquema está em falta — e o chamador não lhe pode passar nenhuma das duas: só monta a cadeia a partir de esquemas que já encontrou presentes, e só combina quando essa cadeia não fica vazia.
A salvaguarda mantém-se porque é a recusa de uma entrada malformada por parte de uma biblioteca exportada. Removê-la não removeria nenhuma interrupção que uma compilação possa alcançar; transformaria uma recusa clara numa falha abrupta para um chamador fora do compilador que passasse uma entrada destas, o que é estritamente pior.
A cadeia em si não é assunto deste passo. Uma cadeia que forma um ciclo e uma cadeia que ultrapassa o limite de profundidade são recusadas pelo único percurso de extends: antes de qualquer esquema ser combinado — ver acima «Cyclic extends chain (Cadeia extends cíclica)» e «An extends: chain runs past the depth bound (Uma cadeia de extensão ultrapassa o limite de profundidade)».
Está catalogada porque está declarada e tem um código próprio, pelo que um código que se tenha em mãos se resolve. Nada do que se possa escrever produz uma, e encontrar uma significaria que a disposição descrita acima já não se verifica — vale a pena comunicá-lo como defeito em vez de o contornar.
An explicit value displaced one an annotation supplied (Um valor explícito substituiu um que uma anotação fornecia)
Um aviso. A expansão orientada por anotações transforma uma anotação que um Aggregate ou uma Release traz num anexo de Feature com configuração própria. Quando o mesmo anexo traz também configuração escrita explicitamente — no componente, num âmbito acima dele ou na Release —, o valor explícito prevalece em cada chave que ambos abrangem. Essa é a regra pretendida e a saída emitida não está errada, pelo que a compilação termina. O que o aviso nomeia é a consequência: o contributo da anotação para essa chave deixa de estar visível em qualquer parte da saída, e o autor que escreveu a anotação pode não saber que foi suprimido.
Comunica cada substituição em vez de apenas as que alteraram alguma coisa. A fusão sobrescreve o valor suprimido, pelo que não resta nenhuma comparação a fazer nem nada que possa dizer se os dois coincidiam — o rasto de que uma substituição aconteceu é toda a evidência. É lido depois de toda a cascata de anexos e a expansão terem sido combinadas, que é o primeiro ponto em que esse rasto existe.
A sua mensagem começa assim:
annotation contribution overridden by an explicit value (contributo da anotação sobrescrito por um valor explícito)
e continua com a anotação que foi substituída, depois as coordenadas da chave que a substituiu, depois o sítio onde a anotação substituída foi escrita. A posição que o antecede é o documento em que se encontra a constatação e a chave dentro dele:
<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>") (no ficheiro e na chave indicados: contributo da anotação sobrescrito por um valor explícito (anotação, componente, anexo, pilar, chave em causa e sítio onde a anotação foi declarada indicados))
Dois desses valores são fáceis de interpretar mal. O valor component só é nomeado quando a entrada que substitui tem um componente: uma entrada escrita para todo um âmbito não tem componente próprio, e nomear um que nunca teve enviaria o leitor para uma chave que ninguém escreveu. E annotation declared at nomeia o sítio onde a anotação substituída foi escrita, que é o âmbito de que foi herdada sempre que não foi escrita no componente que a substituiu — portanto não é a chave do componente repetida sob outra legenda.
O que fazer: nada, quando o valor explícito é o pretendido. O aviso existe para que a precedência seja uma escolha e não uma surpresa. Quando não é o pretendido, há duas saídas e diferem no alcance. Eliminar a entrada explícita, e o valor da anotação chega até essa chave. Ou remover a anotação do componente ou do âmbito que a traz, e nenhum contributo é feito — o que afeta também todas as outras chaves que essa anotação fornece. Quando ambos os lados são pretendidos, mas para chaves diferentes, restringir aquele que vai mais longe do que o pretendido, para que os dois deixem de se sobrepor.
A connection crosses between two different providers’ assembled outputs (Uma ligação atravessa as saídas montadas de dois fornecedores diferentes)
Quando as duas extremidades de uma ligação de dependência são montadas em saídas diferentes, um fornecedor que anuncia a ligação entre fronteiras cabla-a nativamente — publicando uma referência no lado produtor e resolvendo-a no lado consumidor. Essa cablagem é escrita no vocabulário próprio de um fornecedor, e um fornecedor não consegue resolver uma referência que outro publicou. Assim, uma ligação cujas duas extremidades são renderizadas por fornecedores diferentes não é cablada por nenhum deles.
Isto avisa e não interrompe a compilação. A ligação continua a transportar o seu valor: o contrato de injeção encaminha o escalar do lado produtor até ao lado consumidor exatamente como faz em qualquer outro sítio, pelo que o que fica é uma ligação que funciona, cablada da forma comum, e não uma ligação partida. O que a constatação indica é que a cablagem nativa que talvez se esperasse não aconteceu — e a saída fica inalterada quer se aja sobre ela, quer não.
Basta um fornecedor anunciar a ligação para haver comunicação. As duas extremidades não precisam de a reivindicar: uma reivindicação significa que a cablagem nativa era esperada e é impossível, e o autor que anexou esse fornecedor é quem a queria. Exigir as duas reivindicações não diria nada na Release mista comum, em que um fornecedor faz a ligação e o outro não, que é precisamente o caso a que isto se destina.
O sítio onde as extremidades foram colocadas não entra em conta. Uma saída montada é identificada pelo seu caminho e pelo seu fornecedor em conjunto, pelo que duas extremidades cujos fornecedores diferem estão sempre em saídas diferentes, seja qual for a sua colocação. O que é lido são os dois fornecedores e as suas duas reivindicações.
É comunicado uma vez por cada ligação desse tipo, posicionado no documento e na chave em que a ligação foi escrita.
Mensagem emitida, que começa pela extremidade distante e depois nomeia o socket e o fornecedor de cada extremidade:
cross-boundary link between endpoints rendered by different providers is not supported ("<target-component>", socket "<socket>", consumer provider "<provider>", target provider "<provider>") (a ligação entre fronteiras entre extremidades renderizadas por fornecedores diferentes não é suportada (componente de destino, socket, fornecedor do consumidor e fornecedor de destino indicados))
Como corrigir: quando o valor escalar que a ligação já transporta é suficiente, não há nada a fazer — trata-se de uma notificação e não de uma falha. Quando se pretende a cablagem nativa, as duas extremidades têm de ser renderizadas por um único fornecedor: mover uma extremidade para uma fronteira que passe pelo fornecedor da outra, ou servir ambas as capacidades com um só. Quando nenhuma das duas coisas é possível, a forma que transporta o valor é a que a Release tem, e a ligação funciona.
A command-line plugin runner was built without a way to find plugins (Um executor de plugins de linha de comandos foi construído sem uma forma de encontrar plugins)
Um plugin que contribui com um comando de terminal é executado por um componente que tem primeiro de transformar a referência do plugin em bytes. Esta condição comunica que esse componente foi construído sem a parte que faz essa transformação, pelo que não há caminho da referência até algo para executar.
Diz respeito a um comando de terminal e não a uma compilação, pelo que nenhuma fase da compilação a alcança: é levantada onde um comando instalado é despachado, e a resposta que produz é a falha desse comando ao arrancar, e não uma interrupção em qualquer compilação.
Nenhum caminho na ferramenta de linha de comandos distribuída a pode levantar. Todos os sítios onde a ferramenta constrói esse componente fornecem a pesquisa, pelo que a salvaguarda só é acionada onde outra coisa o constrói e deixa a pesquisa de fora.
Mensagem emitida, que é a própria frase da condição:
cliplugin: no plugin resolver configured (cliplugin: nenhum resolvedor de plugins configurado)
Como corrigir: nada nos ficheiros de entidade causa isto, e nada do que se possa escrever num catálogo ou num espaço de trabalho o elimina. Quando se executa a ferramenta de linha de comandos publicada, esta não é uma condição que se possa alcançar — um comando instalado que não arranca está a comunicar outra coisa, e a mensagem que imprimiu é a que deve ser lida. Quando se incorpora o executor de plugins em software próprio, fornecer, ao construí-lo, a pesquisa que resolve uma referência de plugin para os seus bytes.
A registry alias is already bound to another host (Um alias de registo já está associado a outro host)
Uma recusa ao adicionar um registo ao espaço de trabalho, não numa compilação. Um alias é um nome curto que seleciona uma entrada de registo, pelo que é único entre as entradas. Registar um alias já detido por um host diferente é recusado, em vez de se permitir que encubra a associação existente, o que mudaria silenciosamente o destino de cada referência que use esse alias.
Voltar a adicionar o mesmo host sob o seu alias existente não é um conflito — isso atualiza a entrada no próprio sítio, que é o que faz voltar a executar o comando para alterar as outras definições de um host.
Mensagem emitida, que nomeia o alias e o host que já o detém:
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: o alias de registo indicado já é usado pelo host indicado; escolher um alias diferente ou dirigir-se diretamente a esse host: o alias de registo já é usado por outro host)
Como corrigir: a correção cabe ao operador, na linha de comandos. Dar ao novo registo um alias diferente, ou deixá-lo sem alias e referi-lo pelo host. Quando se pretendia mover o alias para o novo host, removê-lo primeiro da entrada que a mensagem nomeia em .aggrega-config.yaml — a recusa existe para que mover um alias seja algo feito de propósito e não um efeito secundário de adicionar um registo.
A registry serves a trust document that cannot be read as one (Um registo serve um documento de confiança que não pode ser lido como tal)
Uma recusa ao adicionar um registo, não numa compilação. Um registo pode publicar as identidades de assinatura com que espera que os artefactos sejam assinados, para que a adição do registo as possa fixar em vez de obrigar um operador a transcrevê-las. Esta condição comunica um registo que respondeu com um documento que não pode ser usado como política de confiança.
É uma recusa definitiva precisamente porque o endpoint respondeu. Um registo que não publica nada é um resultado comum e esperado, que é tolerado; um que publica algo ilegível é uma configuração incorreta, e não fixar nada a partir dele deixaria o registo silenciosamente por fixar, parecendo que tinha sido fixado.
São comunicadas aqui três estruturas: conteúdo que não se descodifica de todo, incluindo um documento que traz um campo que o formato não define; uma entrada de identidade que não nomeia nem uma identidade exata nem um padrão; e uma entrada de identidade sem emissor. As duas últimas são recusadas porque uma entrada destas nunca pode corresponder a uma assinatura, pelo que enfraqueceria a fixação parecendo reforçá-la.
Mensagens emitidas. Conteúdo que não se descodifica:
registrytrust: advertised trust config is malformed: <what the decoder reported> (registrytrust: a configuração de confiança anunciada está malformada, seguida daquilo que o descodificador comunicou)
uma entrada de identidade sem nada com que corresponder:
registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set identity or identity_regexp (registrytrust: a configuração de confiança anunciada está malformada: na lista e no índice indicados, uma entrada de identidade tem de definir identity ou identity_regexp)
e uma sem emissor:
registrytrust: advertised trust config is malformed: <list>[<index>]: an identity entry must set issuer (registrytrust: a configuração de confiança anunciada está malformada: na lista e no índice indicados, uma entrada de identidade tem de definir issuer)
Cada uma é enquadrada pelo comando que a encontrou:
Como corrigir: a correção cabe a quem opera o registo, e não ao utilizador — citar-lhe a mensagem, já que nomeia a entrada exata e aquilo que lhe falta. Para avançar entretanto, adicionar o registo sem fixar a política que anuncia e fornecer pessoalmente as identidades ou a chave; o comando aceita-as diretamente, que é também o que se faz para um registo que não publica política nenhuma.
A registry publishes no trust document (Um registo não publica nenhum documento de confiança)
Um resultado comum e esperado, e não uma falha, e não interrompe nada. Um registo pode publicar as identidades de assinatura que espera, e a maioria não o faz. Quando lhe é pedido um documento destes, um registo assim responde que não o tem, e a adição do registo prossegue — o resultado é comunicado como uma notificação e as identidades são, em vez disso, fixadas manualmente.
É deliberadamente distinto de um registo que não pôde ser contactado. Este respondeu; a resposta foi que não publica nenhuma política. Manter os dois separados é o que permite tolerar uma ausência deliberada enquanto um problema de acessibilidade continua visível como tal.
Comunicado como uma notificação, que nomeia o registo, o que respondeu e o que fazer em vez disso:
Notice: <host> publishes no trust policy (HTTP 404); pin its trust by hand with —identity or —key (Notificação: o host indicado não publica nenhuma política de confiança (HTTP 404); fixar a sua confiança manualmente com —identity ou —key)
A condição sob a qual está catalogado é registrytrust: registry advertises no trust config.
O hub oficial é a exceção: traz uma linha de base integrada, pelo que, quando não publica nenhum documento, é essa linha de base que é fixada em vez disso, e a notificação diz o que o hub respondeu e que a linha de base é usada no seu lugar, em vez de pedir que se fixem identidades.
Como corrigir: nada está avariado. Para que as assinaturas deste registo sejam verificadas, fornecer a identidade ou a chave ao adicioná-lo, exatamente como diz a notificação — é o caminho normal para um registo que não publica nenhuma política. Caso contrário, o registo é adicionado sem uma postura de assinatura e os artefactos que dele provêm só são verificados quando trazem uma assinatura.
A registry is added offline with no trust policy to pin (Um registo é adicionado offline sem uma política de confiança a fixar)
Uma recusa ao adicionar um registo, não numa compilação. Adicionar um registo é o único momento em que a sua confiança é fixada: as identidades de assinatura que anuncia são obtidas uma vez e cada pull posterior verifica em relação a essa cópia fixada. Quando o espaço de trabalho está offline, essa obtenção não pode ser feita, pelo que o registo nunca é consultado. Em vez de escrever uma entrada que não confia em nada — e à qual cada pull posterior sujeitaria o registo —, adicionar um registo que não seja o hub oficial é recusado, a menos que a política seja fornecida pelo próprio utilizador.
Três casos não são recusados. Fornecer identidades ou uma chave regista exatamente essas e não faz qualquer obtenção, pelo que funciona da mesma forma offline e online. O hub oficial é adicionado com a sua linha de base integrada, que traz consigo quer a obtenção seja feita, quer não. E pedir que não haja obtenção — --fetch-trust=false — regista a entrada a partir das flags, exatamente como faz online.
Encontra-se onde quer que um registo seja adicionado: aggrega registry add, aggrega config init --registry <host>, os pedidos aggrega/registryAdd e aggrega/configInit de aggrega serve, cuja mensagem de erro traz o código curto antes da frase, e as ferramentas de registo de aggrega mcp, que executam esses comandos. Inicializar uma configuração não aceita identidades nem chave, pelo que, offline, só pode inicializar o hub; qualquer outro registo deve ser adicionado com aggrega registry add.
Mensagem emitida, que é a própria frase da condição:
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> (um registo que não seja o hub oficial não é registado offline sem uma política de confiança fornecida manualmente, porque a política que anuncia não pode ser obtida; registá-lo uma vez enquanto se está online, ou fixar a sua confiança manualmente com uma identidade e o seu emissor ou com um ficheiro de chave pública)
enquadrado pelo comando que o encontrou e pelo registo que nomeia:
aggrega registry add: <host>: <the message above> (aggrega registry add: o host indicado e, depois, a mensagem acima)
Como corrigir: adicionar o registo uma vez enquanto o espaço de trabalho está online — passar --offline=false nessa única execução, ou limpar a definição offline — para que a sua política anunciada seja obtida e fixada; depois não há nada a repetir, uma vez que os pulls posteriores verificam em relação à cópia fixada. Quando não for possível ficar online, fornecer a política manualmente: uma ou mais entradas --identity <identity>=<issuer> para um registo sem chave, ou --key a apontar para o seu ficheiro de chave pública para um registo com chave, que é o que se teria fixado a partir do seu anúncio.
A tag is already published with different content (Uma tag já está publicada com conteúdo diferente)
Uma recusa ao publicar, não numa compilação. Os bytes publicados ficam congelados: antes de qualquer coisa ser carregada, a versão de destino é consultada e o digest para o qual aponta é comparado com o digest que o conteúdo em mãos produziria. Uma versão que já aponta para conteúdo diferente é recusada.
Voltar a publicar conteúdo idêntico byte a byte não é um conflito. Os digests coincidem, nada é carregado e o comando indica que a versão já está publicada — pelo que voltar a executar uma publicação que teve êxito em parte é seguro, e completa a publicação: a data de publicação que ainda falta à versão, e a sua assinatura quando o push assina, são anexadas, e uma versão a que não falte nenhuma delas não recebe nada, como descreve Concluir uma publicação que um push anterior deixou parcial.
Não existe nenhuma flag que anule isto. O conteúdo alterado é publicado sob uma nova versão, o que deixa aos consumidores uma versão para a qual mudar deliberadamente, em vez de uma versão que mudou sem que dessem por isso.
Mensagens emitidas, que indicam a versão, o digest que contém e o digest oferecido. Ao publicar uma entidade do catálogo, que também indica a verificação que confirma o incremento de versão:
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: a versão indicada já está publicada com o digest existente indicado; recusa-se a substituí-la pelo digest proposto — publicar uma nova versão (aggrega lint —pre-publish verifica o incremento): oci: tag já publicada com conteúdo diferente)
e ao publicar um artefacto de dados:
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: a versão indicada já está publicada com o digest existente indicado; recusa-se a substituí-la pelo digest proposto — publicar uma nova versão: oci: tag já publicada com conteúdo diferente)
Como corrigir: aumentar a versão e publicar novamente. Para uma entidade do catálogo, isso significa metadata.version e o diretório por versão em que a entidade se encontra, que mudam em conjunto. Antes de o fazer, verificar se a alteração é intencional: os dois digests diferirem numa versão que se julga não ter sido tocada significa que o conteúdo em disco não é o conteúdo que foi publicado, e descobrir porquê vale mais do que publicar por cima. A verificação prévia à publicação indicada na mensagem compara uma versão com a anterior e é a forma de confirmar que o incremento está correto.
An entity shares its directory with another entity (Uma entidade partilha o seu diretório com outra entidade)
Uma recusa ao fixar e ao publicar, não numa compilação. Cada tipo de entidade tem um diretório próprio, exceto os três que uma raiz do espaço de trabalho contém lado a lado: um Aggregate, uma Release e um Manifest. Uma entidade publicada é um artefacto numa coordenada para cada versão, e o diretório em que é escrita reflete isso — o passo de fixação escreve o único ficheiro entity.lock para o qual um diretório tem espaço, e uma publicação empacota a entidade a partir do seu diretório. Assim, uma entidade de qualquer outro tipo com outra entidade ao lado é recusada nesses dois momentos: por aggrega pin, por um pull ou um push a que se pede para fixar em nome do autor, e por aggrega push, quer fixe quer não. É recusada antes de qualquer coisa ser obtida, e nada é escrito.
Um diretório com várias entidades continua a ser carregado, a passar o lint, a ser validado e a ser compilado. A disposição só é avaliada quando algo é produzido a partir do diretório, que é também o momento em que a mensagem pode indicar a entidade que está a atrapalhar. Um pull que não fixa não escreve nada ao lado da entidade e não é recusado.
O que conta como entidade ao lado é qualquer outro documento YAML diretamente no mesmo diretório cujo kind: seja um tipo de entidade. Os ficheiros próprios de um chart, um fragmento compose, um manifesto do Kubernetes ou um README não são entidades, e um subdiretório — um chart local, uma árvore source/ — não está ao lado da entidade, seja o que for que contenha. Só o tipo e o nome de cada vizinho são lidos, pelo que nada do que um vizinho declare pode mudar a resposta.
O nome do diretório não é avaliado. Uma entidade sozinha no seu diretório é fixada e publicada na versão que declara, onde quer que esse diretório esteja; a disposição <name>/<version>/ que o catálogo da biblioteca padrão usa é uma convenção, e não uma verificação.
Mensagem emitida, que indica a entidade, cada entidade ao lado dela e os ficheiros a 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 (a entidade partilha o seu diretório com outra entidade, e uma entidade do seu tipo tem um diretório próprio (a Recipe indicada e, ao lado dela, a Recipe indicada no ficheiro indicado). correção: dar a cada entidade um diretório próprio — mover o ficheiro indicado para um diretório próprio, juntamente com qualquer ficheiro que só essa entidade leia; só os tipos Aggregate, Manifest e Release podem partilhar um diretório com outras entidades)
Como corrigir: mover cada entidade que a mensagem indica para um diretório próprio, levando consigo os ficheiros que só ela lê — um chart local, um ficheiro importado e o ficheiro entity.lock, se registar as fixações dessa entidade — e executar aggrega pin em cada uma que leia uma origem remota ou importe um ficheiro, para que cada lock registe a sua própria entidade. Dispor cada uma como <kind>/<provider-or-publisher>/…/<name>/<version>/ mantém-na onde o catálogo da biblioteca padrão guarda todas as entidades. Um diretório de catálogo é encontrado percorrendo-o, pelo que uma compilação sobre o catálogo renderiza a mesma saída após a mudança.
An entity kind has no artifact media type (Um tipo de entidade não tem tipo de média de artefacto)
Uma recusa ao publicar, não numa compilação. Cada tipo de entidade publicável tem um tipo de média para cada uma das duas formas que o seu artefacto assume — só o seu documento, ou um arquivo do documento e dos ficheiros que declara — e o empacotamento de uma entidade procura-o pelo tipo. Esta condição comunica um tipo sem entrada.
Nenhuma compilação a alcança. O único outro sítio onde a mesma consulta é executada trata uma entrada em falta como «isto não é uma biblioteca» e prossegue, pelo que a condição nunca aparece aí.
Mensagem emitida, a frase própria da condição enquadrada pelo comando e pelo ficheiro que estava a empacotar:
aggrega push: bundle <path>: oci: unknown entity kind for mediatype dispatch (aggrega push: bundle no caminho indicado: oci: tipo de entidade desconhecido para a seleção do tipo de média)
Como corrigir: comparar o campo kind: do ficheiro que se está a publicar com os tipos que aggrega push --list-kinds imprime — um tipo mal escrito ou não suportado é comunicado aqui, e corrigir o campo é toda a correção. Quando o tipo é um dos que essa lista apresenta, trata-se de uma lacuna no conjunto de ferramentas e não na entidade, e vale a pena comunicá-la citando o tipo.
A published archive carries an entry Windows cannot use (Um arquivo publicado traz uma entrada que o Windows não consegue usar)
Um aviso levantado quando uma entidade é publicada; nunca interrompe nada, e uma compilação não o levanta. Uma entidade que traz ficheiros ao lado do seu documento é publicada como um arquivo, e cada nome que o arquivo contém — o próprio nome de ficheiro do documento da entidade e, depois, cada ficheiro que traz — é avaliado pela regra que a interrupção «A name the operation writes holds a part Windows cannot hold (Um nome que a operação escreve contém uma parte que o Windows não consegue conter)» acima aplica no Windows: uma parte que o Windows reserva para um dispositivo, em qualquer combinação de maiúsculas e minúsculas e seja qual for a extensão que se lhe siga, ou uma parte que termine num ponto ou num espaço. Assim, aux/x.yaml provoca-o pelo seu diretório aux, report. pelo seu ponto final, e um documento chamado con.yaml que importa um ficheiro de esquema, pelo seu próprio nome. Uma entidade que não traz nada é publicada apenas como o seu documento, disposto sob um nome que o produto escolhe, e um Plugin não publica nenhum arquivo, pelo que nenhum dos dois o provoca.
É levantado em todas as plataformas e não recusa nada. Um espaço de trabalho no Windows recusa-se a dispor uma entrada destas, sob essa interrupção, pelo que não consegue usar a versão; o aviso é a forma como quem publica o descobre antes de alguém no Windows o descobrir. A publicação, ou a sua execução de teste, prossegue ou para exatamente como faria sem ele.
Cada superfície que publica uma entidade levanta-o, cada uma na sua própria forma.aggrega push, e o seu --dry-run, imprime uma linha por entrada na saída de erro padrão, cada uma a começar por warning: . A ferramenta publish-entity do assistente responde com as entradas como windows_unusable_entries, e o texto da resposta também as indica. aggrega serve responde a aggrega/publishEntity com elas como windowsUnusableEntries e passa as próprias linhas de aviso a um pedido que pediu para ser informado. Cada resposta omite o campo quando não existe nenhuma entrada destas.
A sua mensagem começa assim:
an entry this publication carries cannot be used on Windows (uma entrada que esta publicação traz não pode ser usada no Windows)
e continua com a entrada e a primeira das suas partes que o Windows não consegue conter, depois a correção. Explicado em «A published archive carries an entry Windows cannot use (Um arquivo publicado traz uma entrada que o Windows não consegue usar)» em warnings.md.
Como corrigir: mudar o nome da parte que a mensagem indica, em disco e onde quer que as declarações da entidade indiquem o ficheiro, e publicar novamente. Quando a versão não se destina a ser usada no Windows, não é preciso mudar nada.
Two catalog identities publish to one repository location (Duas identidades do catálogo publicam num mesmo local de repositório)
Uma recusa ao verificar um catálogo inteiro, não numa compilação. O local para onde uma entidade é publicada é derivado da sua identidade e convertido em minúsculas, pelo que duas identidades que só diferem em maiúsculas e minúsculas acabam no mesmo sítio. Publicar ambas deixaria os bytes de uma entidade substituídos pelos da outra, e nada em nenhuma das duas entidades o diria.
A verificação é executada sobre todo o catálogo de uma vez, porque uma colisão é uma propriedade de um par e não de cada entidade isoladamente — nenhuma está errada por si só, e ler qualquer uma delas isoladamente não mostra nada.
Mensagem emitida. Abre com a moldura da verificação do catálogo, depois a frase própria da condição, depois cada grupo em colisão, cada um com o local partilhado e as identidades que o alcançam:
catalog validation failed: oci: distinct catalog identities map to the same OCI repository location: (a validação do catálogo falhou: oci: identidades de catálogo distintas correspondem ao mesmo local de repositório OCI)
<location> <- <identity>, <identity>
Como corrigir: mudar o nome de uma das entidades que a mensagem indica, no seu metadata.name e no diretório que o reflete. A escolha de qual mudar cabe ao utilizador; os pares que só diferem em maiúsculas e minúsculas são a forma habitual, e escolher uma grafia e usá-la de forma consistente é o que impede o par de voltar a surgir. Mudar o nome é uma alteração real da identidade de uma entidade, pelo que tudo o que se refere ao nome antigo tem de acompanhar a mudança — o que é uma razão para resolver a colisão antes de qualquer um dos nomes ser publicado, e não depois.
Keyless signing was asked for without the services it needs (A assinatura sem chave foi pedida sem os serviços de que precisa)
Uma recusa ao assinar durante a publicação, não numa compilação. A assinatura sem chave não tem forma offline: obtém uma identidade, faz com que seja emitido para ela um certificado de curta duração, regista a assinatura onde possa ser verificada mais tarde e depois descarta a chave. Cada um destes passos é uma troca com um serviço em execução. Esta condição comunica que a identidade da qual o fluxo parte não estava disponível, pelo que o fluxo é recusado em vez de ser iniciado e abandonado a meio.
Duas formas comunicam-na: nada configurado para fornecer uma identidade, e algo configurado que não produziu nada.
Um espaço de trabalho offline comunica-o de outra forma, sob a recusa que abrange todos os passos de rede, porque a recusa acontece antes de alguma identidade chegar a ser pedida.
Mensagens emitidas. Nenhuma origem de identidade:
signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token source is required (signing: a assinatura sem chave requer um fornecedor de identidade ativo, Fulcio e Rekor: é necessária uma origem de token de identidade)
e uma origem que não produziu nada:
signing: keyless signing requires a live identity provider, Fulcio, and Rekor: an identity token is required (signing: a assinatura sem chave requer um fornecedor de identidade ativo, Fulcio e Rekor: é necessário um token de identidade)
Como corrigir: a correção cabe ao operador, na forma como a publicação é executada. Num pipeline automatizado, a identidade vem das próprias credenciais do pipeline, pelo que isto normalmente significa que não foi concedida ao job a permissão que as emite. Numa execução interativa, a identidade vem do início de sessão, que o comando irá pedir. Quando não se pretende de todo uma identidade ativa, assinar antes com uma chave própria — esse caminho não precisa de nenhum destes serviços, e é o que se deve usar a partir de um ambiente que não os consegue alcançar.
An unsigned publish targets a registry or a policy that requires a signature (Uma publicação não assinada tem como destino um registo ou uma política que exige uma assinatura)
Uma recusa ao publicar, não numa compilação. Quando é exigida uma assinatura, o conteúdo não assinado não é publicado. A verificação é executada antes de qualquer byte ser carregado, pelo que nada parcial chega ao registo.
Duas condições, porque um requisito tem duas origens e as correções diferem. Uma é a posição própria do registo de destino, que se aplica a tudo o que nele é publicado. A outra é a política de assinatura do espaço de trabalho, que abrange um conjunto de tipos de artefacto onde quer que sejam publicados. Quando ambas se verificam, é comunicada a do registo, porque indicar o destino é a mais útil das duas.
Não existe aqui nenhuma flag que publique conteúdo não assinado. Desativar explicitamente a assinatura não atenua a recusa — apenas muda a predefinição para os artefactos em que a assinatura é opcional.
A assinatura é produzida antes do carregamento e não depois, pelo que uma falha de assinatura também vem parar aqui e nada é publicado.
Mensagens emitidas. O requisito próprio do registo:
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: o registo indicado exige assinaturas; voltar a executar assinando o artefacto (não existe aqui nenhuma flag para fazer push de conteúdo não assinado): signing: o registo exige assinaturas; recusa-se a fazer push de conteúdo não assinado)
o da política do espaço de trabalho, que indica o tipo que trouxe o artefacto para o seu â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: a política de assinatura exige uma assinatura para o tipo indicado; voltar a executar assinando o artefacto (não existe aqui nenhuma flag para fazer push de conteúdo não assinado): signing: a política de assinatura exige uma assinatura para este tipo de artefacto; recusa-se a fazer push de conteúdo não assinado)
e uma assinatura que não foi possível produzir, que é comunicada sob a condição do registo e cita a falha subjacente:
aggrega push: sign <reference>:<version>: <the underlying failure>: signing: registry requires signatures; refusing to push unsigned content (aggrega push: assinatura da versão indicada: a falha subjacente indicada: signing: o registo exige assinaturas; recusa-se a fazer push de conteúdo não assinado)
Uma forma de falha de assinatura é indicada especificamente, porque uma rejeição genérica leva as pessoas a voltar a obter uma credencial que não pode ajudar:
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: assinatura da versão indicada: o token de identidade não traz nenhuma claim de e-mail ou subject verificada — o fluxo/cliente OIDC não devolveu uma identidade com âmbito de e-mail (voltar a exportar ou a obter o token não vai ajudar); configurar o fornecedor de identidade/cliente/âmbito para que devolva uma: a falha subjacente indicada: signing: o registo exige assinaturas; recusa-se a fazer push de conteúdo não assinado)
Como corrigir: a correção cabe ao operador. Assinar o artefacto e publicar novamente — com uma chave própria ou pelo caminho sem chave, conforme a configuração do espaço de trabalho. Quando não se esperava que fosse exigida uma assinatura, a mensagem diz que origem a exigiu: a posição própria de um registo está na entrada desse registo em .aggrega-config.yaml, e o requisito limitado a um tipo está na política de assinatura de todo o espaço de trabalho. Atenuar qualquer um deles é uma decisão sobre o que se está disposto a publicar sem assinatura, pelo que restringir o âmbito da política é normalmente melhor do que desativá-la.
References signed together need different signing credentials (Referências assinadas em conjunto precisam de credenciais de assinatura diferentes)
Uma recusa ao assinar, não numa compilação. aggrega sign com várias referências, e aggrega deprecate --from com um ficheiro de lote, assinam tudo o que recebem com uma única credencial: uma única chave própria, ou uma única identidade sem chave. A credencial de que uma referência precisa é decidida pela configuração do seu registo — um signing.key_path que se aplique a esse registo seleciona a chave que indica, e quando nenhum se aplica a referência é assinada sem chave. Quando as referências indicadas em conjunto precisariam de credenciais diferentes — uma chave para um registo e nenhuma para outro, ou duas chaves diferentes —, nada é assinado, e a mensagem indica os registos de cada lado.
A verificação é executada antes de ser pedida uma identidade e antes de qualquer registo ser lido, pelo que nada é assinado nem anexado e não é pedido nada a ninguém para uma execução que não vai avançar. Uma assinatura não pode ser retirada a quem já a obteve, e é por isso que a execução é recusada em vez de ser assinada com a credencial de que uma das referências precise.
Uma chave passada com --key decide por todas as referências. Aplica-se a todas as referências indicadas, independentemente do que a configuração diga para cada registo, pelo que uma execução destas nunca é recusada aqui.
Encontra-se onde quer que um lote seja assinado: aggrega sign, aggrega deprecate --from, os pedidos aggrega/signArtifacts e aggrega/deprecateArtifact de aggrega serve, cuja mensagem de erro traz o código curto antes da frase, e as ferramentas sign-artifacts e deprecate-artifact de aggrega mcp. Uma chamada de ferramenta que chega a um servidor através de um listener nunca usa uma chave que a configuração indique, pelo que aí cada referência é assinada com a identidade que a chamada envia e a chamada não é recusada aqui.
Mensagem emitida. Abre com a frase própria da condição, cada credencial segue-se com os registos para os quais assinaria, e a correção vem no fim:
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: as referências indicadas em conjunto precisam de credenciais de assinatura diferentes, pelo que nada foi assinado (o registo indicado assina com a chave própria que signing.key_path indica, o registo indicado assina sem chave: não se aplica nenhum signing.key_path). correção: assiná-las em execuções separadas, uma por credencial: as referências no registo indicado, depois as referências no registo indicado; cada execução assina como assinaria por si só)
e, quando um registo do lote exige assinaturas, indicando-o no fim da correção:
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: as referências indicadas em conjunto precisam de credenciais de assinatura diferentes, pelo que nada foi assinado (o registo indicado assina com a chave própria que signing.key_path indica, o registo indicado assina sem chave: não se aplica nenhum signing.key_path). correção: assiná-las em execuções separadas, uma por credencial: as referências no registo indicado, depois as referências no registo indicado; cada execução assina como assinaria por si só, e o registo indicado exige assinaturas, pelo que esta recusa retém uma assinatura que de outro modo teria avançado, e não uma assinatura impossível de fazer)
Um segundo registo com uma chave própria é indicado como assinando «with a different held key (com outra chave própria)». O caminho de uma chave nunca é impresso: a mensagem indica a definição, que é o que se pode alterar.
Como corrigir: dividir as referências pela credencial de que os seus registos precisam e executar uma vez por credencial — um aggrega sign que indique as referências nos registos assinados com uma chave, outro que indique as restantes; para aggrega deprecate --from, um ficheiro de lote por credencial. Cada execução assina então como teria assinado por si só. Para assinar antes todas as referências com uma única chave numa única execução, passar essa chave com --key.
A detached signature does not verify against the key supplied (Uma assinatura destacada não é verificada com a chave fornecida)
O resultado negativo de verificar uma assinatura isolada sobre um payload em relação a uma chave pública, inteiramente offline: o payload difere do que foi assinado, a assinatura foi alterada, ou a chave não é a que a produziu.
Nada no conjunto de ferramentas distribuído a alcança. A verificação a que pertence não tem nenhum chamador fora dos seus próprios testes, pelo que nenhum comando que um utilizador execute — compilação, pull ou publicação — a comunica. Está catalogada aqui para que o código remeta para algo, e não porque uma compilação a possa imprimir. A verificação que um pull efetivamente faz incide sobre um bundle de assinatura completo e é comunicada à parte.
Mensagem emitida, que cita o que o verificador comunicou:
signing: signature does not verify: <what the verifier reported> (signing: a assinatura não é verificada, seguido do que o verificador comunicou)
Como corrigir: nada nos ficheiros de entidade causa isto, e nada que se possa escrever num catálogo ou num espaço de trabalho o elimina. Quando se executa a ferramenta de linha de comandos publicada, esta não é uma condição que se possa alcançar, e um problema de assinatura que se esteja efetivamente a ver é comunicado, em vez disso, por uma das condições de verificação de bundle descritas acima. Quando se usa o pacote de assinatura diretamente a partir de software próprio, o payload, a assinatura e a chave têm de ser os três que vão juntos — um payload reserializado entre a assinatura e a verificação é a causa habitual, uma vez que os bytes passam a diferir mesmo que o conteúdo pareça o mesmo.
A resolved artifact is not a documentation bundle (Um artefacto resolvido não é um bundle de documentação)
Uma referência que resolve para um artefacto de outro tipo — uma entidade do catálogo, um plugin — é rejeitada em vez de ser guardada em cache como documentação, pelo que uma referência mal apontada falha onde é apontada, e não mais tarde como um bundle que não pode ser lido.
Onde surge. O bundle de documentação é adquirido para a cache que todos os projetos da máquina partilham, a partir do registo configurado do espaço de trabalho sob o namespace reservado docs: pelo servidor destinado a assistentes uma vez, ao arrancar e antes de responder a qualquer coisa, por aggrega explain e pela explicação de um código num editor na primeira vez que qualquer um deles precise, e por aggrega scaffold --example — em cada caso apenas quando a máquina não tem nenhuma cópia que a verificação de assinaturas do espaço de trabalho admita. Esta é a verificação que cada aquisição executa sobre o que voltou.
Nunca interrompe uma sessão. A aquisição comunica o seu resultado no fluxo de logs do servidor e a conexão prossegue de qualquer modo; o que um artefacto rejeitado custa são os recursos de documentação, que respondem então «não encontrado» nessa sessão. aggrega scaffold --example não tem nada para escrever sem o bundle, pelo que aí se trata da recusa do comando, e nada é escrito.
Mensagem emitida, que indica a referência e ambos os tipos de média:
docscache: <reference>@<version> has media type "<what was found>", want "<what a documentation bundle is>": docscache: artifact is not a documentation bundle (docscache: a referência indicada na versão indicada tem o tipo de média encontrado, quando se esperava o de um bundle de documentação: docscache: o artefacto não é um bundle de documentação)
Como corrigir: nada nos ficheiros de entidade causa isto, e nenhuma alteração de autoria o elimina. A referência que a aquisição usou aponta para algo que não é um bundle de documentação — verificar o registo configurado do espaço de trabalho, uma vez que a referência do bundle é derivada dele, e uma referência bem formada que aponta para outro artefacto é resolvida com êxito e só falha aqui.
A page is absent from a documentation bundle (Uma página está ausente de um bundle de documentação)
Um bundle de documentação foi guardado em cache e o seu conteúdo verificado, e a página pedida — ou, no caso de aggrega scaffold --example, o diretório do exemplo — não está nele. É diferente de não haver bundle nenhum: o bundle está presente e íntegro, e a entrada falta nele.
Não chega a nenhuma compilação. A superfície que serve páginas de documentação a um editor ou a um assistente transforma-a numa resposta comum de «não encontrado» para o recurso pedido. aggrega scaffold --example comunica-a como uma recusa que indica o exemplo e o bundle, seguida de uma indicação para aggrega scaffold --example --list, que imprime os exemplos que o bundle de facto contém, e não escreve nada.
Vale a pena saber distinguir qual das duas respostas de «não encontrado» se recebe, mesmo que a superfície as apresente da mesma forma. Esta significa que o bundle está em cache e íntegro e que a página não está nele. A outra — nenhum bundle que o espaço de trabalho possa ler, porque nenhum está em cache ou a única cópia é uma que a verificação de assinaturas do espaço de trabalho recusa — significa que a aquisição não foi concluída, e o fluxo de logs do servidor diz porquê.
Mensagem emitida, que indica a página e o bundle em que foi procurada:
page "<page>" in <reference>@<version>: docscache: page not found in documentation bundle (a página indicada na referência e na versão indicadas: docscache: página não encontrada no bundle de documentação)
Como corrigir: nada está avariado nos ficheiros. Uma página que falta no bundle falta porque o bundle é anterior a ela ou porque o caminho pedido não é o caminho sob o qual é publicada — o bundle é adquirido na versão que o servidor indica como sua, pelo que uma página adicionada depois dessa versão não está nele. Quando a página nunca existiu, o pedido indicou um caminho que a documentação não usa, e a documentação publicada é o sítio onde encontrar o que ela usa.
An edit would produce a document its schema refuses (Uma edição produziria um documento que o seu esquema recusa)
Uma recusa numa edição de documento, não numa compilação. Uma edição estruturada — adicionar um componente, anexar uma Feature, fazer a cablagem de uma aresta ou definir um valor — é composta e inserida no documento, e o resultado é depois verificado em relação ao esquema do tipo de documento que é. Quando essa verificação levanta uma objeção, a edição é recusada e nada é escrito. Pertence a aggrega edit-document, e à mesma capacidade alcançada por um editor através de aggrega serve ou por um assistente, que são pontos de entrada finos para uma única implementação.
O tipo é lido do documento, nunca fornecido por quem chama. Um chamador que indicasse o tipo poderia indicar o errado, e o resultado seria então verificado em relação a um esquema segundo o qual o documento não está escrito — o que admitiria exatamente a edição que esta verificação existe para recusar.
O ficheiro fica byte a byte como estava, e a escrita é atómica, pelo que uma edição recusada é indistinguível de uma nunca tentada, e um pedido corrigido pode ser repetido sobre o documento com que se começou.
O seu objeto é um pedido bem formado. O pedido indicava uma edição que esta capacidade aplica, e o documento que teria produzido é um que o esquema de autoria teria recusado se tivesse sido escrito à mão — e é por isso que nenhuma regra de autoria é repetida para ele: pedir a uma Release que traga um valor do programador é recusado pelo mesmo esquema de qualquer modo. Um pedido que nunca visou uma edição — um caminho de nó que não alcança nada no documento, um valor escrito como mapeamento onde é exigido um escalar, uma entrada já presente que traz outra coisa — é recusado por motivos próprios, e cada superfície comunica-o no seu próprio canal.
Um documento que já era inválido também o comunica. A verificação é executada mesmo quando a edição não mudou nada, pelo que uma edição sobre um documento que o produto se recusaria a ler di-lo em vez de comunicar sucesso.
A verificação é a que todas as leituras do documento aplicam, pelo que também recusa uma Recipe ou FeatureRecipe cujo pipeline declara duas vezes o mesmo id de passo, uma regra que nenhum esquema consegue exprimir; a objeção após a frase abre então com a frase e o conselho próprios dessa condição, conforme descrito em A pipeline declares one step id twice (Um pipeline declara duas vezes o mesmo id de passo).
Mensagem emitida, que traz a objeção própria do esquema após a frase — o tipo de documento e o ficheiro, depois a posição, a chave com problema e o que o esquema disse aí — e termina com o conselho:
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 (a edição foi recusada porque o documento resultante não seria válido, e nada foi escrito: a validação do envelope do documento falhou (o tipo indicado, no caminho indicado); a linha e a coluna indicadas: o caminho do campo indicado: … seguido da objeção própria do esquema. corrigir o documento para que corresponda ao esquema do seu tipo)
Como corrigir: abrir o documento na posição que a mensagem cita e ler a objeção, que diz o que o esquema queria nessa chave. A alteração a fazer é normalmente no pedido e não no documento — pedir uma entrada que o esquema admita nesse lugar, e o mesmo pedido aplica-se sem problemas. Quando a chave é uma que o tipo desse documento não pode trazer de todo, pertence à superfície de autoria que pode, e a página da entidade desse tipo indica os campos que declara. O que é semanticamente admissível não é decidido neste ponto — se um socket de dependência é um que o produtor declara, por exemplo —, pelo que esta recusa diz sempre respeito à forma do documento, nunca ao que pode ser consumido através de uma conexão.
An annotation key uses a prefix the platform reserves (Uma chave de anotação usa um prefixo que a plataforma reserva)
Uma recusa ao verificar uma entidade face às convenções de publicação, não numa compilação. O prefixo aggrega.ai/, e feature.aggrega.ai/ fora de uma Feature, pertencem à plataforma: uma chave escrita sob um deles transporta um significado que a plataforma atribui, pelo que uma entidade própria que aí escreva reivindica um espaço de nomes que não detém.
Avisa durante a autoria e recusa no controlo de publicação, e ambas as leituras indicam esta mesma condição. O que foi encontrado é o mesmo em ambos os casos; só a consequência difere. Essa divisão é a forma como se comporta a maioria das regras das convenções de publicação catalogadas aqui, pelo que é enunciada uma vez e dada como adquirida nas entradas abaixo que não digam o contrário — as duas que comparam com uma versão já publicada dizem-no nas suas próprias entradas, porque não podem de todo ser executadas sobre conteúdo local.
A sua mensagem começa assim:
an annotation key on the entity uses a prefix the platform reserves (uma chave de anotação da entidade usa um prefixo que a plataforma reserva)
Como corrigir: mover a chave para debaixo de um prefixo que pertença à própria organização. Quando um espaço de trabalho tiver ainda assim um motivo para escrever sob o prefixo reservado, esta regra é uma das que têm uma opção de exclusão, descritas em «As regras de disciplina» em aggrega-lint.md.
An entity’s name does not follow the shape its kind expects (O nome de uma entidade não segue a forma que o seu tipo espera)
Uma recusa ao verificar uma entidade face às convenções de publicação, não numa compilação. Cada tipo de entidade tem uma convenção de forma de nome — o número de segmentos para os tipos cloud-native, PascalCase para os tipos de biblioteca — e o nome que esta entidade declara não corresponde ao que o seu tipo espera.
A sua mensagem começa assim:
the entity’s name does not follow the documented name shape for its kind (o nome da entidade não segue a forma de nome documentada para o seu tipo)
Como corrigir: mudar o nome da entidade para a forma que o seu tipo espera; as convenções por tipo estão listadas em «As regras de disciplina» em aggrega-lint.md, juntamente com a opção de exclusão para um catálogo que nomeia deliberadamente as entidades à sua maneira.
A schema uses a dynamic reference that cannot be resolved ahead of time (Um esquema usa uma referência dinâmica que não pode ser resolvida antecipadamente)
Uma recusa ao verificar uma entidade face às convenções de publicação, não numa compilação. Um esquema que a entidade traz usa uma construção de referência dinâmica, cujo destino é escolhido enquanto um documento está a ser validado, em vez de ser fixado quando o esquema é escrito. Aqui as referências são expandidas antecipadamente, pelo que não existe nenhuma validação em curso face à qual uma construção destas possa ser resolvida.
A sua mensagem começa assim:
a schema in the entity uses a dynamic reference construct that cross-document reference resolution cannot follow (um esquema na entidade usa uma construção de referência dinâmica que a resolução de referências entre documentos não consegue seguir)
Como corrigir: substituir a construção dinâmica por uma referência simples que indique diretamente o destino. Quando o esquema precisar realmente da construção e não for referenciado entre documentos, a regra tem uma opção de exclusão descrita em «As regras de disciplina» em aggrega-lint.md.
A schema declares an identifier the platform owns (Um esquema declara um identificador que pertence à plataforma)
Uma recusa ao verificar uma entidade face às convenções de publicação, não numa compilação. Um esquema que a entidade traz declara um identificador próprio, quando o identificador canónico é derivado da identidade da entidade. O declarado substitui o derivado, pelo que uma referência escrita face ao identificador canónico deixa de ser resolvida.
A sua mensagem começa assim:
a schema in the entity declares an identifier of its own, where the platform owns that schema’s identity (um esquema na entidade declara um identificador próprio, quando a identidade desse esquema pertence à plataforma)
Como corrigir: remover o identificador declarado e deixar que seja derivado. A opção de exclusão, para um esquema publicado deliberadamente sob um identificador próprio, está descrita em «As regras de disciplina» em aggrega-lint.md.
A Component’s category label and its directory name different categories (A etiqueta de categoria de um Component e o seu diretório indicam categorias diferentes)
Uma recusa ao verificar uma entidade face às convenções de publicação, não numa compilação. Um Component tem uma etiqueta de categoria e está arquivado sob um diretório de categoria; a convenção é que ambos indiquem a mesma categoria, para que o diretório que um leitor percorre e a etiqueta com que um seletor faz a correspondência não possam divergir.
A sua mensagem começa assim:
the entity’s category label does not match the category directory the entity is filed under (a etiqueta de categoria da entidade não corresponde ao diretório de categoria sob o qual a entidade está arquivada)
Como corrigir: alterar aquele dos dois que estiver errado para que concordem — mover o ficheiro para debaixo do diretório que a sua etiqueta indica, ou corrigir a etiqueta para a categoria que o diretório indica. O conjunto fechado de categorias, e a opção de exclusão, estão em «As regras de disciplina» em aggrega-lint.md.
A schema extension is written directly into schema content (Uma extensão de esquema é escrita diretamente no conteúdo do esquema)
Uma recusa ao verificar uma entidade face às convenções de publicação, não numa compilação. Um Component ou uma Feature escreve uma extensão de esquema do Aggrega diretamente no conteúdo do seu esquema, quando a entidade dispõe de uma superfície de primeira classe para declarar o mesmo. A forma escrita diretamente funciona, e a convenção prefere a superfície declarada porque é essa que as páginas das entidades ensinam e essa que as ferramentas leem.
Esta é a única regra do grupo que uma compilação também comunica, como um aviso que não interrompe a compilação. Verificar a entidade face às convenções de publicação no controlo de publicação eleva a mesma constatação a uma recusa.
A sua mensagem começa assim:
the entity writes an Aggrega schema extension directly into schema content instead of declaring it under usesSchema or featuresSchema (a entidade escreve uma extensão de esquema do Aggrega diretamente no conteúdo do esquema em vez de a declarar no esquema de sockets ou no esquema de anexos)
Como corrigir: mover a extensão para a superfície de sockets ou de anexos própria da entidade, que é onde as páginas das entidades component.md e feature.md a declaram. A opção de exclusão está em «As regras de disciplina» em aggrega-lint.md.
A Plugin pins neither runtime cap, so the platform’s own apply (Um Plugin não fixa nenhum dos dois limites de execução, pelo que se aplicam os da plataforma)
Um aviso levantado quando uma entidade é verificada face às convenções de publicação, tanto durante a autoria como no controlo de publicação; nunca interrompe nada, e uma compilação não o levanta. Um Plugin declara o limite máximo de memória e o limite de tempo que o host aplica quando carrega e executa o plugin. Um que não declare nenhum dos dois é executado com os valores predefinidos da plataforma, o que é um resultado suportado e não um erro — pelo que aquilo que isto comunica é que os valores predefinidos estão em vigor e que é possível fixá-los explicitamente.
A sua mensagem começa assim:
the Plugin entity declares no runtime resource cap of its own, so the platform defaults apply (a entidade Plugin não declara nenhum limite de recursos de execução próprio, pelo que se aplicam os valores predefinidos da plataforma)
Como corrigir: fixar os limites de que o plugin realmente precisa, ou deixar deliberadamente os valores predefinidos em vigor. A regra não tem nenhuma definição de exclusão, e o motivo é que comunica um facto sobre a entidade e não um juízo sobre ela: não há nada a afrouxar. Os campos estão descritos em plugin.md.
An attachment slot admits only secret material without saying it handles it (Um slot de anexo admite apenas material secreto sem dizer que o trata)
Um aviso levantado quando uma entidade é verificada face às convenções de publicação, tanto durante a autoria como no controlo de publicação; nunca interrompe nada, e uma compilação não o levanta. Um slot de anexo pode fixar, através do seu seletor, que só uma Feature que transporte segredos o possa preencher, e pode registar separadamente que aquilo que o preencher trata material secreto. O seletor estabelece que preenchimentos são admissíveis; o registo estabelece o tratamento. Um slot que fixa o primeiro e omite o segundo deixa que o tratamento seja inferido a partir do seletor, em vez de lido no slot. Cada slot que uma entidade declara é verificado: os do seu próprio bloco de anexos e, num Component, os que um socket de dependência declara para cada ligação cablada através dele — a constatação sobre o slot de um socket indica o socket ao lado do slot.
A sua mensagem começa assim:
an attachment slot admits only secret material and does not declare that it handles it (um slot de anexo admite apenas material secreto e não declara que o trata)
Como corrigir: declarar o tratamento no slot, ao lado do seletor que fixa aquilo que admite. A regra não tem nenhuma definição de exclusão, pelo mesmo motivo pelo qual a regra dos limites do Plugin não a tem: comunica um facto sobre a entidade e deixa a decisão ao utilizador.
A Recipe publishes a provides key its Component does not declare, checked at publication (Uma Recipe publica uma chave que o seu Component não declara, com verificação na publicação)
Um aviso levantado quando uma entidade é verificada face às convenções de publicação, tanto durante a autoria como no controlo de publicação; nunca interrompe nada, e uma compilação não o levanta. Uma Recipe publica uma chave sob provides:, e o Component que a Recipe implementa não declara essa chave no pilar provides do seu esquema. Um consumidor que faz a cablagem através de uma ligação lê o contrato declarado do Component, e não aquilo que a Recipe emita, pelo que a chave é produzida e depois recusada onde algo tenta consumi-la.
🔴 Duas condições descrevem isto, e não são a mesma. O aviso que uma compilação comunica está documentado acima em «A Recipe publishes a provides key its Component does not declare (Uma Recipe publica uma chave que o seu Component não declara)»; esta é levantada quando a entidade é verificada face às convenções de publicação, e tem o seu próprio código. A constatação é o mesmo facto encontrado em duas superfícies — ler o código no diagnóstico para saber qual se tem em mãos.
A sua mensagem começa assim:
the Recipe publishes a provides key the Component it implements does not declare, so a consumer wiring that key is refused (a Recipe publica uma chave provides que o Component que implementa não declara, pelo que um consumidor que faça a cablagem dessa chave é recusado)
Como corrigir: declarar a chave no Component, para que o contrato que um consumidor lê inclua aquilo que a Recipe emite — ou deixar de a publicar a partir da Recipe quando nada se destina a consumi-la. A opção de exclusão está em «As regras de disciplina» em aggrega-lint.md.
A Component’s metrics annotation and its provides key disagree (A anotação de métricas de um Component e a sua chave provides divergem)
Um aviso levantado quando uma entidade é verificada face às convenções de publicação, tanto durante a autoria como no controlo de publicação; nunca interrompe nada, e uma compilação não o levanta. Um Component pode indicar como se autenticam as métricas do seu produto, na sua anotação observability.aggrega.ai/metrics-credential — none, target-key ou separate-token — e pode declarar a chave provides metrics_credential_required, que cada uma das suas Recipes publica para dizer se as métricas de uma instância precisam de uma credencial. As duas são um único facto sobre o produto visto de dois lados, pelo que um Component que afirma que as suas métricas não precisam de credencial não declara nenhuma chave destas, e um que afirma que precisam de uma credencial declara-a. Esta condição comunica um Component em que as duas divergem, indicando o Component, o valor da anotação e a chave que está a mais ou em falta.
A sua mensagem começa assim:
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 anotação de um Component que indica como se autenticam as suas métricas diverge de declarar ou não a chave provides que diz que as métricas de uma instância precisam de uma credencial)
Como corrigir: corrigir aquele dos dois que estiver errado — declarar metrics_credential_required no pilar provides, e publicá-la a partir de cada Recipe, quando as métricas precisam de uma credencial; removê-la quando não precisam de nenhuma; ou alterar a anotação para o valor que descreve o produto. A regra não tem nenhuma definição de exclusão, pelo mesmo motivo pelo qual a regra dos limites do Plugin não a tem; que valores lê, e que Components deixa por ler, está em «As regras de disciplina» em aggrega-lint.md.
A connection and the target it reaches do not name one key (Uma ligação e o destino que alcança não indicam uma mesma chave)
Um aviso levantado quando uma Release é verificada face às convenções de publicação; nunca interrompe nada, e uma compilação não o levanta. Um servidor que verifica uma chave guarda a chave que verifica num slot próprio, e um chamador apresenta uma chave na ligação através da qual alcança esse servidor. Nenhuma das duas extremidades vê a da outra, pelo que as duas só são uma única chave porque os seus autores escrevem o mesmo localizador em ambas as extremidades. Esta condição comunica uma ligação cujo destino declara o slot para a chave que exige aos seus chamadores, nos casos em que não são uma mesma chave: a ligação transporta uma credencial e o slot de chave do destino não está preenchido, o slot de chave do destino está preenchido e a ligação não transporta nenhuma credencial, ou ambos estão preenchidos e os dois escrevem os seus localizadores de forma diferente.
Ao contrário das regras que a precedem, esta lê uma Release inteira e não uma única entidade, pelo que só é encontrada quando uma Release é verificada e nunca no controlo de publicação, que verifica uma única entidade isoladamente; onde quer que seja comunicada, é um conselho. A constatação indica o componente, a ligação, o destino e os dois slots, e nunca cita nenhum dos dois localizadores. Um scrape — uma ligação no socket scrape_target — é avaliado por aquilo que o seu destino afirma sobre as suas métricas: não é avaliado de todo quando a anotação observability.aggrega.ai/metrics-credential do destino diz none, nunca face à chave do destino quando diz separate-token, e como qualquer outra ligação nos restantes casos; uma ligação em qualquer outro socket é avaliada seja o que for que o destino afirme.
A sua mensagem começa assim:
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 (uma ligação e o destino que alcança não indicam uma mesma chave: escrevem localizadores diferentes para ela, ou só um dos dois indica uma)
Como corrigir: fazer com que ambas as extremidades leiam um único parâmetro — o campo credential da ligação e o campo api_key do destino — para que a chave que o chamador apresenta e a chave que o servidor verifica não possam ser escritas de forma diferente; ou, quando uma ligação não se destina a apresentar nenhuma chave, retirar-lhe a credencial. Que slots são lidos, o que é comparado e a opção de exclusão estão em «As regras de disciplina» em aggrega-lint.md.
The change being published breaks what the evolution rubric allows (A alteração em publicação viola o que a rubrica de evolução permite)
Uma recusa na verificação que precede a publicação, não numa compilação. A versão em publicação é comparada com a versão já publicada antes dela, e a diferença entre ambas é classificada segundo uma rubrica documentada. Esta condição comunica que a diferença é uma à qual a rubrica levanta objeções.
Precisa de um predecessor publicado com o qual comparar, pelo que ela e a verificação do incremento de versão abaixo são as duas regras deste grupo que não podem ser executadas apenas sobre conteúdo local: sem nenhum registo consultado não há nada a comparar, e a verificação é ignorada em vez de aprovada.
A sua mensagem começa assim:
the version being published changes the published predecessor in a way the documented evolution rubric objects to (a versão em publicação altera o predecessor publicado de uma forma à qual a rubrica de evolução documentada levanta objeções)
Como corrigir: ler a classificação no diagnóstico, que indica o que na alteração motivou a objeção da rubrica, e tornar a alteração compatível ou publicá-la sob uma versão que a admita. A rubrica é apresentada em «A rubrica de incremento de versão» em aggrega-lint.md.
The version offered is a smaller bump than the change requires (A versão oferecida é um incremento menor do que a alteração exige)
Uma recusa na verificação que precede a publicação, não numa compilação. A alteração em publicação é classificada segundo a rubrica de evolução, e a versão oferecida para ela é um passo menor do que essa classificação exige — uma remoção ou um estreitamento oferecido como patch, por exemplo. Um incremento excessivo é sempre aceite; é um incremento insuficiente que para aqui.
Ao contrário das regras que a precedem, esta é decidida aqui e não pelo plugin de convenções. Que incremento foi oferecido só se sabe no momento da publicação, e nesse momento não está em curso nenhuma compilação, pelo que a comparação entre a classificação e a versão oferecida é feita nesse ponto.
A sua mensagem começa assim:
the version bump being published is smaller than the evolution check’s classification of the change requires (o incremento de versão em publicação é menor do que exige a classificação da alteração feita pela verificação de evolução)
Como corrigir: publicar sob a versão que a classificação exige; o diagnóstico indica qual é. Quando se considera que a alteração é menor do que a sua classificação indica, a rubrica em «A rubrica de incremento de versão» em aggrega-lint.md diz o que coloca uma alteração em cada classe. A primeira publicação de uma entidade não tem predecessor, pelo que a comparação é ignorada e comunicada como não realizada em vez de aprovada.
An import stopped partway through translating a source (Uma importação parou a meio da tradução de uma origem)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. O importador comunicou um diagnóstico suficientemente grave para interromper a tradução, pelo que aquilo que produziu é parcial: parte da origem tornou-se ficheiros de criação provisórios e parte não.
O resultado parcial é deliberado, e não um destroço. Indica o desfecho e não a causa — aquilo que não pôde ser traduzido é comunicado nos diagnósticos que o acompanham, um por cada construção que o importador não conseguiu transpor, nas palavras do próprio importador. Esta condição é o que permite a um chamador distinguir «a importação parou e produziu parte de uma resposta» de «a importação falhou por completo», que são situações diferentes com passos seguintes diferentes.
A sua mensagem começa assim:
the importer reported a diagnostic that stops the import, so the source was not fully turned into draft authoring files (o importador comunicou um diagnóstico que interrompe a importação, pelo que a origem não foi totalmente transformada em ficheiros de criação provisórios)
Como corrigir: ler os diagnósticos comunicados ao lado dela — cada um indica uma construção da origem que o importador não conseguiu traduzir. A correção está na origem fornecida, ou em concluir o rascunho manualmente: uma importação produz um ponto de partida para editar, pelo que uma construção que não sobreviveu à tradução deve ser escrita diretamente do lado do Aggrega. aggrega-import.md descreve o que o comando produz e onde escreve.
More than one importer recognises the source (Mais de um importador reconhece a origem)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. A importação não nomeou nenhum formato, pelo que o formato foi reconhecido a partir das assinaturas que os importadores declaram — tanto os do catálogo do espaço de trabalho como os importadores core do compilador, cada um dos quais indica a sintaxe em que uma origem é lida, os nomes de ficheiro a que se aplica e os caminhos que a sua árvore analisada deve ou não deve conter — e corresponderam à origem assinaturas de importadores que servem mais de um formato. A importação não escolhe entre eles: o formato em que uma origem está é uma afirmação dos importadores, não do compilador, e escolher seria um palpite que entregaria a origem a um importador ao qual talvez não se destine.
Isto não é o mesmo que um único formato anunciado por mais de um importador, descrito em «A parse or import format is advertised by more than one plugin (Um formato de análise ou de importação é anunciado por mais de um plugin)» acima. Aí o formato está definido e os importadores que o servem concorrem, pelo que uma entrada plugins.importer escolhe entre eles; aqui são os próprios formatos que diferem, pelo que nenhum anexo resolve a questão, e nomear o formato resolve-a. Um importador que reconhece uma origem reconhece-a como cada formato que anuncia, pelo que um importador que anuncia mais de um formato, uma de cujas assinaturas corresponde, também é recusado aqui.
A sua mensagem começa assim:
more than one importer recognises the source (mais de um importador reconhece a origem)
O resto da mensagem indica a origem e cada formato como o qual foi reconhecida, pela ordem das identidades e versões dos importadores, e depois a solução:
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>) (mais de um importador reconhece a origem (origem indicada, reconhecida como os formatos indicados). Passar —format para nomear o formato em que a ler (por exemplo —format seguido de um dos formatos))
Como corrigir: nomear o formato — --format em aggrega import, ou format na ferramenta de importação do assistente e no método aggrega/import da sessão. Quando um dos importadores nunca deveria reconhecer uma origem destas, a alteração é nas assinaturas desse importador, que o seu autor declara no seu autorrelatório describe() e que a sua entidade Plugin regista quando é gerada; ou, quando se trata de um que o catálogo do espaço de trabalho contém, deixá-lo fora do catálogo que o espaço de trabalho lê — um importador core está sempre entre os experimentados, pelo que uma origem que um deles reconhece juntamente com outro importador se resolve nomeando o formato. aggrega-import.md descreve como um formato é reconhecido.
No importer recognises the source (Nenhum importador reconhece a origem)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. A importação não nomeou nenhum formato, pelo que o formato foi reconhecido a partir das assinaturas que os importadores declaram — tanto os do catálogo do espaço de trabalho como os importadores core do compilador — e as assinaturas de nenhum formato corresponderam à origem. A importação não adivinha: entregar a origem a um importador que nunca declarou ler essa forma geraria um rascunho a partir de uma origem à qual talvez não se destine.
É a contrapartida de «More than one importer recognises the source (Mais de um importador reconhece a origem)» acima. Aí vários formatos reivindicam a origem; aqui nenhum o faz. Em ambos, nomear o formato resolve a questão, e nada é escrito até que seja nomeado.
A sua mensagem começa assim:
no importer recognises the source (nenhum importador reconhece a origem)
O resto da mensagem indica a origem, depois a solução e cada formato que os importadores do catálogo anunciam, pela ordem em que foram lidos:
no importer recognises the source (source "<source>"). Pass —format to name it explicitly (for example —format <format> or —format <format>) (nenhum importador reconhece a origem (origem indicada). Passar —format para o nomear explicitamente (por exemplo —format seguido de um dos formatos anunciados))
Quando nenhum importador anuncia qualquer formato, a solução indica-o em vez dos exemplos.
A um diretório é oferecida uma solução diferente, porque nomear um formato qualquer não o pode ajudar. Um diretório é lido apenas através dos padrões de ficheiro que o seu importador declara, e uma assinatura que não declara nenhum padrão de ficheiro não se aplica a nenhum dos ficheiros de um diretório — assim, um diretório que contém, por exemplo, uma única exportação do Langflow não é reconhecido por nenhuma assinatura, e nomear o formato langflow seria, por sua vez, recusado nos termos de An importer that declares no file patterns is handed a directory (Um importador que não declara padrões de ficheiro recebe um diretório). Por isso, a recusa de um diretório nomeia-o como diretório e propõe importar um dos seus ficheiros isoladamente, ou nomear um formato cujo importador declare padrões de ficheiro — apenas esses formatos, lidos nas próprias declarações dos importadores:
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>) (nenhum importador reconhece a origem (diretório). Importe isoladamente um dos ficheiros do diretório, ou passe —format com o nome de um formato cujo importador leia um diretório através dos padrões de ficheiro que declara (por exemplo —format ou —format))
Quando nenhum importador declara um padrão de ficheiro, a recusa propõe importar isoladamente um dos ficheiros do diretório e indica que nenhum importador do catálogo declara os padrões de ficheiro através dos quais um diretório é lido.
Como corrigir: nomear o formato — --format em aggrega import, ou format na ferramenta de importação do assistente e no método aggrega/import da sessão, cada um dos quais formula a recusa em torno do campo que recebe e a abre com o código curto desta condição; a resposta da sessão também contém os dois códigos da condição nos seus dados. Para um diretório, importar isoladamente o ficheiro pretendido — uma assinatura que não nomeia nenhum ficheiro aplica-se a um ficheiro importado isoladamente, seja qual for o seu nome — ou nomear um dos formatos que a recusa enumera. Quando a origem deveria ter sido reconhecida, a alteração é nas assinaturas do importador que serve o seu formato, que o seu autor declara no seu autorrelatório describe() e que a sua entidade Plugin regista quando é gerada. aggrega-import.md descreve como um formato é reconhecido.
An importer that declares no file patterns is handed a directory (Um importador que não declara padrões de ficheiro recebe um diretório)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. A origem nomeada é um diretório, e um diretório é entregue ao seu importador exatamente como os ficheiros que os padrões de ficheiro declarados pelo importador selecionam — pelo que os ficheiros de um diretório que um importador lê são uma afirmação do próprio importador. O importador que serve o formato da origem não declara padrões de ficheiro: lê um único ficheiro e nada diz sobre quais ficheiros de um diretório são seus.
Nada é aberto. A importação para assim que o importador é resolvido e antes de qualquer ficheiro do diretório ser lido, em vez de entregar ao importador todos os ficheiros que o diretório contém.
A sua mensagem começa assim:
the importer serving the source’s format declares no file patterns, so it reads one file and cannot read a directory (o importador que serve o formato da origem não declara padrões de ficheiro, pelo que lê um único ficheiro e não consegue ler um diretório)
O resto da mensagem indica o formato, o importador e o diretório tal como foi nomeado, e depois a solução:
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 (o importador que serve o formato da origem não declara padrões de ficheiro, pelo que lê um único ficheiro e não consegue ler um diretório (formato, importador e diretório indicados). Importar antes um dos ficheiros do diretório isoladamente; o importador lê um diretório a partir do momento em que declara os padrões de ficheiro pelos quais os seus ficheiros são nomeados)
Como corrigir: importar isoladamente um ficheiro do formato. Para que um importador leia diretórios do seu formato, o seu autor declara os padrões pelos quais os seus ficheiros são nomeados — o campo files de uma assinatura de reconhecimento no seu autorrelatório describe(), que a sua entidade Plugin regista quando é gerada. aggrega-import.md descreve o que uma importação de um diretório lê.
No file in the directory matches the importer’s file patterns (Nenhum ficheiro do diretório corresponde aos padrões de ficheiro do importador)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. A origem nomeada é um diretório, o formato está definido e o importador que o serve declara padrões de ficheiro — mas nenhum ficheiro que o diretório contém, a qualquer profundidade, corresponde a um deles. Não entregar nenhuma origem ao importador fá-lo-ia falhar numa origem vazia, com palavras sobre o conteúdo e não sobre que ficheiros foram lidos, pelo que a importação para aqui sem ter lido nada.
Quando o formato foi reconhecido em vez de nomeado, o importador cuja assinatura reconheceu o diretório correspondeu a um dos seus ficheiros, pelo que esta condição só surge quando o importador que é executado não é esse — outro importador do mesmo formato que uma entrada plugins.importer seleciona, ou outra versão dele.
A sua mensagem começa assim:
no file in the directory matches the file patterns the importer serving the source’s format declares (nenhum ficheiro do diretório corresponde aos padrões de ficheiro que o importador que serve o formato da origem declara)
O resto da mensagem indica o formato, o importador, o diretório tal como foi nomeado e cada padrão que o importador declara, e depois a solução:
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 (nenhum ficheiro do diretório corresponde aos padrões de ficheiro que o importador que serve o formato da origem declara (formato, importador, diretório e padrões de ficheiro indicados). Nomear um diretório que contenha um ficheiro a que um desses padrões corresponda, ou o formato de um importador cujos padrões correspondam aos ficheiros que este diretório contém)
Como corrigir: importar o diretório que contém os ficheiros do formato — um padrão é comparado com o final do caminho de um ficheiro dentro do diretório, pelo que conta um ficheiro a qualquer profundidade — ou nomear o formato em que estão os ficheiros do diretório. aggrega-import.md descreve o que uma importação de um diretório lê.
A file read from the directory and a file named in the importer’s with.sources have the same name (Um ficheiro lido do diretório e um ficheiro nomeado nas origens do importador têm o mesmo nome)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. A origem nomeada é um diretório, e os seus ficheiros chegam ao importador como origens com nome, cada um sob o seu caminho dentro do diretório. A entrada plugins.importer que anexa o importador nomeia ficheiros próprios em with.sources, que também lhe chegam como origens com nome, cada um sob o seu nome de base — e um mesmo nome é usado por ambos. Um nome é a forma como um importador distingue uma origem de outra, pelo que entregar-lhe ambos deixaria uma a ocultar a outra sem nada que indique qual; em vez disso, a importação para, sem entregar nada.
A sua mensagem começa assim:
a file read from the directory and a file named in the importer’s with.sources have the same name (um ficheiro lido do diretório e um ficheiro nomeado nas origens do importador têm o mesmo nome)
O resto da mensagem indica o nome e o ficheiro de with.sources, e depois a solução:
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 (um ficheiro lido do diretório e um ficheiro nomeado nas origens do importador têm o mesmo nome (nome e ficheiro de with.sources indicados). Cada origem chega ao importador sob um único nome, pelo que se deve mudar o nome de um dos dois ficheiros, ou deixar o ficheiro fora das with.sources do importador)
Como corrigir: mudar o nome de um dos dois ficheiros, ou retirar o ficheiro do campo with.sources da entrada quando o diretório já o contém. Um ficheiro de with.sources mantém o seu nome de base, pelo que é um ficheiro com o mesmo nome no nível superior do diretório que encontra; um ficheiro num diretório abaixo leva esse diretório no seu nome. Que importador transforma uma origem em rascunhos descreve o campo with.sources de uma entrada.
An import’s target names a capability no Recipe in the catalog binds to (O destino de uma importação nomeia uma capacidade à qual nenhuma Recipe do catálogo se associa)
Uma recusa ao transformar uma descrição de origem externa em ficheiros de criação provisórios, não numa compilação. A importação recebeu um destino — --target em aggrega import, ou target na ferramenta de importação do assistente e no método aggrega/import da sessão — para que gere o rascunho de um Manifest que mapeie cada tipo de componente do rascunho para uma Recipe desse fornecedor. O destino é uma capacidade de fornecedor, comparada com o spec.capability ao qual cada Recipe do catálogo do espaço de trabalho se associa, e nenhuma Recipe aí se associa à indicada. Um Manifest gerado para ela não mapearia nada, e cada tipo de componente surgiria então como em falta no catálogo quando o que está errado é a própria opção — na maioria das vezes um erro de digitação.
Nada é executado e nada é escrito. A importação para assim que o catálogo é carregado, antes de o formato da origem ser reconhecido e antes de o importador ser executado, pelo que nenhum rascunho é produzido e nenhum ficheiro é escrito, também numa simulação.
A sua mensagem começa assim:
no Recipe in the workspace’s catalog binds to the capability the import’s target names (nenhuma Recipe do catálogo do espaço de trabalho se associa à capacidade que o destino da importação nomeia)
O resto da mensagem indica o destino exatamente como foi indicado e as capacidades às quais as Recipes do catálogo de facto se associam, cada uma uma vez e por ordem, e depois a solução:
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 (nenhuma Recipe do catálogo do espaço de trabalho se associa à capacidade que o destino da importação nomeia (destino indicado, capacidades às quais as Recipes do catálogo se associam). Nomear uma dessas capacidades como destino, ou omitir o destino, e nenhum Manifest é gerado; nada foi gerado nem escrito)
Quando o catálogo não contém nenhuma Recipe, a mensagem indica-o em vez da lista, e a solução é adicionar ao catálogo uma Recipe do fornecedor.
Como corrigir: nomear uma das capacidades que a mensagem lista — compose ou helm, por exemplo, tal como o spec.capability de uma Recipe as escreve — ou omitir o destino, o que não gera nenhum rascunho de Manifest. Quando o fornecedor pretendido é um para o qual o catálogo ainda não contém nenhuma Recipe, adicionar as suas Recipes a uma pasta de catálogo que o espaço de trabalho lê primeiro. aggrega-import.md descreve o que gera uma importação que recebe um destino.
A child Release inherits a boundary directory that resolves where its parent writes (Uma Release filha herda um diretório de fronteira que se resolve onde a sua Release pai escreve)
Um aviso. Uma Release estende outra e herda dela o diretório de saída de uma fronteira, e esse diretório não contém nenhuma variável de template — pelo que se resolve no mesmo caminho para ambas, e a compilação da filha escreve onde escreve a compilação da Release pai.
Herdar o diretório é a forma suportada, e não um erro. Um diretório é um template, pelo que uma Release pai o escreve uma vez e uma filha que preenche um parâmetro o resolve noutro local sem duplicar nada; é essa toda a razão pela qual uma filha não precisa de repetir a topologia de fronteiras da sua Release pai. O que é estreito e real é o caso residual que isto nomeia: sem nenhuma variável, não resta nada para resolver de forma diferente.
Não pode causar uma interrupção, e isso é uma propriedade da regra, e não cautela em relação a ela. Escrever no mesmo caminho resolvido é algo que um autor pode legitimamente pretender — uma filha que troca apenas as Recipes de renderização para comparar a sua saída, ou que muda apenas o dimensionamento — pelo que uma regra que interrompesse com base nessa inferência recusaria uma entrada legítima com base num palpite.
A sua mensagem começa assim:
inherited boundary directory carries no template variable, so it resolves to the path the extended Release writes to (o diretório de fronteira herdado não contém nenhuma variável de template, pelo que se resolve no caminho em que a Release estendida escreve)
Como corrigir: quando as duas deviam escrever em locais diferentes, colocar uma referência a um parâmetro no diretório e deixar cada Release preenchê-la. Quando escrever num único caminho é o pretendido, nada precisa de mudar — o aviso indicou o que vai acontecer, e a compilação produz a sua saída de qualquer forma.
Encontrar uma interrupção a partir do código curto que a compilação imprimiu
O cabeçalho entre parênteses retos de um diagnóstico de interrupção indica a categoria à qual a falha é atribuível e, quando a falha nomeia uma das condições catalogadas aqui, o código curto dessa condição — a letra E e quatro dígitos, como em [CATALOG_ERROR E0209]. Um número é atribuído uma vez e depois fica fixo, pelo que um código curto colado num relatório ou numa pesquisa continua a nomear a condição que nomeava quando foi registado. Os outros dois identificadores que uma condição contém, e qual dos três usar e quando, são explicados em sentinels.md.
A própria linha de mensagem da condição começa com uma frase fixa que enuncia a condição. Tudo o que vem depois dessa frase varia com a ocorrência — o documento em causa, a chave escrita, o valor problemático e o conselho para essa ocorrência — e as entradas acima citam a forma completa para a condição que cada uma documenta. A frase fixa é a parte que é igual todas as vezes, e é isso que faz dela a parte com que fazer a correspondência.
A tabela abaixo relaciona as duas, restrita a esta página: para cada condição catalogada aqui, o código curto que uma compilação imprime e a frase com que começa a sua linha de mensagem, ao lado da entrada acima que explica a correção de criação. Os títulos das entradas são citados exatamente, pelo que pesquisar um deles nesta página leva à sua entrada. A tabela de todas as condições resolve um código curto entre todas as condições que o compilador declara, incluindo as que nenhuma entrada aqui cobre.
Quando uma entrada aparece ao lado de dois códigos curtos, cobre duas condições distintas e cada uma regista a sua própria frase; ler as frases em vez do título partilhado para saber qual delas uma compilação comunicou.
aggrega explain <code> faz esta pesquisa no terminal, aceitando qualquer um dos códigos da condição e imprimindo a condição juntamente com a entrada acima que a documenta. É descrito em aggrega explain.
Código curto
Começa com
Documentado em
E0001
cliplugin: no plugin resolver configured
A command-line plugin runner was built without a way to find plugins (Um executor de plugins de linha de comandos foi construído sem uma forma de encontrar plugins)
E0003
malformed attachment requirement
Malformed attachment requirement (Requisito de anexo malformado)
E0004
annotation contribution overridden by an explicit value
An explicit value displaced one an annotation supplied (Um valor explícito substituiu um que uma anotação fornecia)
E0005
policy violation
A governance plugin rejected the build (Um plugin de governação rejeitou a compilação)
E0006
required attachment slot unfilled
Required attachment slot not bound (Slot de anexo obrigatório sem associação)
E0007
selector violation
Cross-node type safety violation via selector: (Violação da segurança de tipos entre nós através de selector)
E0008
attachment slot selector unsatisfied
The Feature filling an attachment slot does not satisfy the slot’s selector (A Feature que preenche um slot de anexo não satisfaz o seletor do slot)
E0009
pipeline step typed-I/O contract violation
A pipeline step’s typed input or output does not satisfy its declared contract (A entrada ou a saída tipada de um passo de pipeline não satisfaz o seu contrato declarado)
E0010
pipeline step failed
A pipeline step failed (Um passo de pipeline falhou)
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 (Um patch de pipeline endereça um documento que o conjunto não contém, ou um sem árvore a endereçar)
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 (Um patch de pipeline endereça um documento que o conjunto não contém, ou um sem árvore a endereçar)
E0013
feature type mismatch between Aggregate and Release
Feature type mismatch between Aggregate and Release (Divergência de tipo de Feature entre Aggregate e Release)
E0014
inject entry carries both `value:` and `from:`; schema requires exactly one
An inject: entry carries both a literal and a source key (Uma entrada de inject traz simultaneamente um literal e uma chave de origem)
E0015
uses-edge inject dictates a delivery mechanism the socket does not permit
uses edge dictates delivery on a socket that allowlists none (Uma aresta dita a entrega num socket que não permite nenhum mecanismo); uses edge dictates a delivery mechanism outside the socket’s allowlist (Uma aresta dita um mecanismo de entrega fora da lista de permissões do socket)
E0016
jsonpatch: test operation failed
A patch’s test operation did not match the document (A operação de teste de um patch não correspondeu ao 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 (Um plugin annotation-transform nomeia um componente que não lhe foi entregue, ou injeta um valor que nenhuma anotação aceita)
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 (As definições de um anexo de governação não correspondem ao esquema declarado do plugin)
E0019
endpoint requires form: reference
A workload: form and the fields beside it do not agree (A forma de uma carga de trabalho e os campos ao lado dela não concordam)
E0020
schedule is not a valid cron expression
A workload schedule: is not an expression the check accepts (O agendamento de uma carga de trabalho não é uma expressão que a verificação aceite)
E0021
persistentTemplate volume requires form: stateful
A workload: form and the fields beside it do not agree (A forma de uma carga de trabalho e os campos ao lado dela não concordam)
E0022
pipeline PATCH target is not parseable structured YAML/JSON
A pipeline step addresses documents the node does not have (Um passo de pipeline endereça documentos que o nó não tem)
E0023
form: reference requires an endpoint
A workload: form and the fields beside it do not agree (A forma de uma carga de trabalho e os campos ao lado dela não concordam)
E0024
schedule requires form: scheduled
A workload: form and the fields beside it do not agree (A forma de uma carga de trabalho e os campos ao lado dela não concordam)
E0025
form: scheduled requires a schedule
A workload: form and the fields beside it do not agree (A forma de uma carga de trabalho e os campos ao lado dela não concordam)
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 (Um artefacto importado já não corresponde ao digest registado ao lado da sua 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 (Uma importação de biblioteca não está escrita na forma de nome simples)
E0028
artifacts output filename collision: two artifact outputs carry the same filename
Two artifact outputs of one Recipe carry the same filename (Duas saídas de artefactos de uma mesma Recipe têm o mesmo nome de ficheiro)
E0029
artifact template references a pillar the Recipe does not declare
An artifacts: template reads a pillar the Recipe does not declare (Um template de artifacts lê um pilar que a Recipe não 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 (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
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 (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
E0032
assembled output collision: two contributors write the same output path
Two contributors write the same output path (Dois contribuidores escrevem o mesmo caminho de saída)
E0033
assertion failed
An assertion stopped the build (Uma asserção parou a compilação)
E0034
duplicate delivery key across attachment-inject and another inject source
An attachment delivers a key another inject source already claimed (Um anexo entrega uma chave que outra fonte de inject já reivindicou)
E0035
provider expected to assemble its dispatch group provides no boundary assembler
The plugin serving a provider cannot assemble what that provider combines (O plugin que serve um fornecedor não consegue montar aquilo que esse fornecedor combina)
E0036
merged-path assembly has conflicting assembly-name annotation values
Chart-name mismatch on a merged helm-chart umbrella (Nome de chart divergente num chart guarda-chuva helm-chart fundido)
E0037
cross-boundary link between endpoints rendered by different providers is not supported
A connection crosses between two different providers’ assembled outputs (Uma ligação atravessa as saídas montadas de dois fornecedores diferentes)
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 (O mesmo nome é derivado mais de uma vez dentro da saída)
E0039
FeatureRecipe template references a per-component-only field with executionScope: boundary
FeatureRecipe template references a field outside its scope’s allowlist (O template de FeatureRecipe referencia um campo fora da lista de permissões do seu âmbito)
E0040
library $import: carries a registry host; reference the library by bare-name identity
A library $import: addresses its library by registry location (Uma importação de biblioteca endereça a sua biblioteca pela localização no registo)
E0041
multiple contributors share an instance ID at the same dispatch path
Instance-ID collision across boundaries assembling to the same path (Colisão de ID de instância entre fronteiras que se montam no mesmo caminho)
E0042
locals entry references a sibling defined later in the same block
locals: entry references a sibling defined later in the same block (Uma entrada de locals referencia uma entrada irmã definida mais abaixo no mesmo bloco)
E0043
template references a key the locals block does not declare
locals: key does not exist (A chave de locals não 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 (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
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 (Uma importação de biblioteca não está escrita na forma de nome simples)
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 (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
E0047
assembled output retains an unresolved cross-boundary link placeholder
Assembled output still carries a cross-boundary placeholder (A saída montada ainda transporta um marcador de posição entre fronteiras)
E0048
dispatch path produced multiple provider outputs
Path collision: two contributors emit at incompatible paths (Colisão de caminhos: dois contribuidores emitem em caminhos incompatíveis)
E0049
path template references a field not in the documented allowlist
Path-template references a variable outside the allowlist (O template de caminho referencia uma variável fora da lista de permissões)
E0050
pipeline /host operation from a step with no host component
A pipeline step addresses documents the node does not have (Um passo de pipeline endereça documentos que o nó não tem)
E0051
pipeline PATCH targets an assembler provider's pre-assembly fragments
A pipeline patch addresses output that has not been assembled yet (Um patch de pipeline endereça uma saída que ainda não foi montada)
E0052
pipeline PATCH targets a document the node did not emit
A pipeline step addresses documents the node does not have (Um passo de pipeline endereça documentos que o nó não tem)
E0053
pipeline plugin is not compatible with the rendering provider
A pipeline step’s plugin does not claim the provider rendering what it addresses (O plugin de um passo de pipeline não reivindica o fornecedor que renderiza aquilo que o passo endereça)
E0054
provider rejected node input
A provider refused a node’s input (Um fornecedor recusou a entrada de um nó)
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 (Uma Recipe ou FeatureRecipe não publica uma chave provides que o seu contrato declara)
E0056
provides template evaluation failed
A provides: template could not be evaluated (Não é possível avaliar um template de provides)
E0057
provides block references a root outside the self-contained set
provides: template references a non-self-contained root (O template de provides referencia uma raiz não autocontida)
E0058
provider render is not deterministic
A provider rendered the same input twice and produced different output (Um fornecedor renderizou a mesma entrada duas vezes e produziu saídas diferentes)
E0059
duplicate delivery key across self-inject and uses-inject
Duplicate delivery key across inject sources (Chave de entrega duplicada entre as fontes de inject)
E0060
template references a root the render context does not define
Template references a root the render context does not define (O template referencia uma raiz que o contexto de renderização não define); Self-inject value template references cross-node data (O template do valor de self-inject referencia dados entre nós)
E0061
unknown provider
Unknown provider (Fornecedor desconhecido)
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 (Um componente declara um mecanismo de inject para o qual a Feature anexada não mapeia 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 (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
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 (Uma importação de biblioteca não está escrita na forma de nome simples)
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 (Uma importação de biblioteca nomeia uma biblioteca ou uma entrada que o catálogo não contém)
E0066
uses edge target does not exist
Dangling uses target (Destino de aresta pendente)
E0067
active toggle did not resolve to a boolean
An active: toggle does not resolve to true or false (Um interruptor não se resolve em true nem em false)
E0068
max sub-aggregate nesting depth exceeded
Sub-aggregate nesting depth exceeded (Profundidade de aninhamento de subagregados excedida)
E0069
mutator patch rejected
A label-transform plugin’s patch reaches outside node labels (O patch de um plugin label-transform vai além dos rótulos dos nós)
E0070
re-exported component alias forms a cycle
A re-published component alias points back at itself (Um alias de componente republicado aponta para si próprio)
E0071
release edge retargets a developer-declared edge
Release retargets a developer-declared edge (A Release muda o destino de uma aresta declarada pelo programador)
E0072
sub-aggregate load failed
A module a composition imports cannot be loaded, or imports itself (Um módulo que uma composição importa não pode ser carregado, ou importa-se a si próprio)
E0073
flattened node ID collision: rename one of the colliding instances so their flattened IDs differ
Two instances flatten to one identifier (Duas instâncias são achatadas num único identificador)
E0074
release per-edge configuration has no edge to apply to
Release per-edge configuration has no edge to apply to (A configuração por aresta da Release não tem nenhuma aresta à qual se aplicar)
An Aggregate reached graph building without being normalised (Um Aggregate chegou à construção do grafo sem ter 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 (Os componentes de um submódulo não estão posicionados em nenhuma fronteira)
E0077
uses edge target was pruned because its active toggle resolved to false
A uses edge targets a component an active: toggle removed (Uma aresta tem como destino um componente que um interruptor removeu)
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 (Um plugin pede ao host que analise uma origem enquanto já está em curso uma análise para ele)
E0079
wasm: recorded command mirror does not match plugin describe()
A Plugin entity’s recorded command set does not match the plugin (O conjunto de comandos registado de uma entidade Plugin não corresponde ao plugin)
E0080
wasm: entity contract claim does not match plugin describe()
A Plugin entity’s claims disagree with the plugin’s own self-report (As afirmações de uma entidade Plugin divergem da autodescrição do próprio 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 (Um plugin devolveu um diagnóstico com uma severidade que não está declarada)
E0082
wasm: guest plugin reported an error
A plugin failed while it was running (Um plugin falhou durante a execução)
E0083
wasm: guest plugin panicked during call
A plugin failed while it was running (Um plugin falhou durante a execução)
E0084
wasm: stamped host-function record does not match .wasm imports
A Plugin entity’s recorded host functions do not match the binary (As funções host registadas de uma entidade Plugin não correspondem ao binário)
E0085
wasm: plugin rejected by the sandbox
The sandbox refused a plugin (A sandbox recusou um plugin)
E0086
wasm: plugin invoked proc_exit
A plugin failed while it was running (Um plugin falhou durante a execução)
E0087
wasm: declared plugin type does not match plugin describe()
A plugin is not the kind of plugin the socket expects (Um plugin não é do tipo de plugin que o socket espera)
E0088
wasm: entity metadata.version does not match plugin describe()
A Plugin entity’s recorded version does not match the plugin (A versão registada de uma entidade Plugin não corresponde ao plugin)
E0089
every published version this reference could select has been withdrawn
Every version a reference could select has been withdrawn (Todas as versões que uma referência poderia selecionar foram retiradas)
E0090
format is advertised by more than one importer plugin
A parse or import format is advertised by more than one plugin (Um formato de análise ou de importação é anunciado por mais de um plugin)
E0091
format is advertised by more than one parser plugin
A parse or import format is advertised by more than one plugin (Um formato de análise ou de importação é anunciado por mais de um 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 (Uma capacidade é servida por mais de um plugin fornecedor)
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 (Um Manifest mapeia duas chaves de versões distintas para um mesmo tipo)
E0094
duplicate entity identity within a single catalog directory
Two catalog entities in one directory share an identity (Duas entidades do catálogo num mesmo diretório partilham uma identidade)
E0095
malformed recipe reference in a Manifest mapping value
Manifest mapping value is not a shape a recipe reference accepts (O valor de mapeamento do Manifest não tem uma estrutura que uma referência de receita aceite)
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 (A declaração de implementação da Recipe não corresponde ao tipo de componente mapeado)
E0097
no importer plugin advertises the requested format
No plugin advertises a requested parse or import format (Nenhum plugin anuncia um formato de análise ou de importação pedido)
E0098
no parser plugin advertises the requested format
No plugin advertises a requested parse or import format (Nenhum plugin anuncia um formato de análise ou de importação pedido)
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 (Nenhuma Recipe está mapeada para uma instância de componente ou de funcionalidade)
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 (Uma associação nomeia um plugin que não serve a capacidade)
E0101
no provider-rendering plugin version satisfies the recipe's provider version pin
No provider plugin version satisfies a Recipe’s provider pin (Nenhuma versão de plugin fornecedor satisfaz a fixação de fornecedor de uma 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 (Uma referência de plugin contém um host de registo ou um caminho de artefacto)
E0103
no catalog version satisfies the referenced version constraint
No catalog version satisfies a version constraint (Nenhuma versão do catálogo satisfaz uma restrição de versão)
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 (Uma referência de plugin ou de receita não tem â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 (Uma referência de plugin ou de receita não tem âmbito)
E0106
resolve: invalid library reference URI
A library reference is not written in the identity form (Uma referência a biblioteca não está escrita na forma de identidade)
E0107
resolve: minimal version selection conflict — incompatible library version requirements
Two consumers of one library require incompatible versions (Dois consumidores de uma mesma biblioteca exigem versões incompatíveis)
The catalog view a build was given cannot load the bodies pinning needs (A vista do catálogo fornecida a uma compilação não consegue carregar os corpos de que a fixação precisa)
E0109
resolve: catalog lookup cannot load resolved recipe and plugin bodies
The catalog view a build was given cannot load the bodies pinning needs (A vista do catálogo fornecida a uma compilação não consegue carregar os corpos de que a fixação precisa)
E0110
resolve: source-template evaluation failure at lock time
Resolving a source: coordinate registers a narrower function set (A resolução de uma coordenada source regista um conjunto de funções mais restrito)
E0111
resolve: source-template parse error
Resolving a source: coordinate registers a narrower function set (A resolução de uma coordenada source regista um conjunto de funções mais restrito)
Resolving a source: coordinate registers a narrower function set (A resolução de uma coordenada source regista um conjunto de funções mais restrito)
E0113
resolve: sub-aggregate inclusion depth exceeded
The chain of module imports is deeper than the pin walk descends (A cadeia de importações de módulos é mais profunda do que o percurso de fixação desce)
E0114
resolve: no entity in the catalog matches this URI
A reference names no entity the catalog holds (Uma referência não nomeia nenhuma entidade que o catálogo contenha)
E0115
compactform: ambiguous dispatch — $mode required
A compact-form schema declares a field literally named type (Um esquema em forma compacta declara um campo chamado literalmente assim)
E0116
compactform: constraint not valid for declared type
A compact-form constraint does not apply to the type it was written on (Uma restrição em forma compacta não se aplica ao tipo em que foi escrita)
E0117
compactform: $jsonschema content invalid
A $jsonschema: escape carries content that is not a schema (Um escape contém um conteúdo que não é um esquema)
E0118
compactform: cross-document $ref carries a registry host; reference the library by identity
A $ref: addresses a library by registry location (Uma referência endereça uma biblioteca pela sua localização no registo)
E0119
compactform: $ref unresolvable
A $ref: is not written in a form the compiler can resolve (Uma referência não está escrita numa forma que o compilador consiga resolver)
E0120
compactform: unknown keyword
A compact-form schema uses a keyword the compact form does not know (Um esquema em forma compacta usa uma palavra-chave que a forma compacta não conhece)
E0121
compactform: cross-document $ref target not found
A $ref: is not written in a form the compiler can resolve (Uma referência não está escrita numa forma que o compilador consiga resolver)
E0122
deprecation: build consumes a deprecated entity
The build consumes an artifact its publisher has deprecated (A compilação consome um artefacto que o seu publicador descontinuou)
E0123
docscache: artifact is not a documentation bundle
A resolved artifact is not a documentation bundle (Um artefacto resolvido não é um bundle de documentação)
E0124
docscache: page not found in documentation bundle
A page is absent from a documentation bundle (Uma página está ausente de um bundle de documentação)
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 (O espaço de trabalho está offline e o passo precisa da rede)
E0126
externalinputs: acquisition is disabled for unpinned inputs
A render requests an external input the lockfile does not pin (Uma renderização pede uma entrada externa que o ficheiro de bloqueio não fixa)
E0127
externalinputs: fetched bytes mismatch the pinned digest
Fetched bytes do not match a pinned digest (Os bytes obtidos não correspondem a um digest fixado)
E0128
externalinputs: URL scheme is not allowed
An external input’s URL uses a scheme that is not allowed (O URL de uma entrada externa usa um esquema não permitido)
E0129
externalinputs: store blob mismatches its pinned record
A stored external input no longer matches its record (Uma entrada externa armazenada já não corresponde ao seu registo)
E0130
lockfile: out of date; it no longer matches what its Release resolves to
The lockfile no longer matches what the release resolves to (O ficheiro de bloqueio já não corresponde àquilo em que a Release se resolve)
E0131
lockfile: file failed schema validation
The lockfile does not satisfy its schema (O ficheiro de bloqueio não satisfaz o seu 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 (Um manifesto não traz nenhuma camada do tipo esperado, ou traz mais do que uma)
E0133
oci: cached manifest digest mismatch
Fetched or cached bytes do not match the digest committed for them (Os bytes obtidos ou em cache não correspondem ao digest declarado para eles)
E0135
oci: content digest mismatch
Fetched or cached bytes do not match the digest committed for them (Os bytes obtidos ou em cache não correspondem ao digest declarado para eles)
E0136
oci: network unreachable
The registry could not be reached (Não foi possível contactar o registo)
E0137
oci: artifact not found at remote source
An artifact is not at the source the build was told to find it (Um artefacto não está na fonte onde a compilação foi instruída a encontrá-lo)
E0138
oci: authentication required or failed
The registry will not serve an artifact without credentials it accepts (O registo não serve um artefacto sem credenciais que aceite)
E0139
oci: tag already published with different content
A tag is already published with different content (Uma tag já está publicada com conteúdo diferente)
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 (Um manifesto não traz nenhuma camada do tipo esperado, ou traz mais do que uma)
E0141
oci: distinct catalog identities map to the same OCI repository location
Two catalog identities publish to one repository location (Duas identidades do catálogo publicam num mesmo local de repositório)
E0142
oci: referrer discovery could not be completed
The registry could not answer what is attached to an artifact (O registo não conseguiu responder ao que está anexado a um artefacto)
E0143
oci: unknown entity kind for mediatype dispatch
An entity kind has no artifact media type (Um tipo de entidade não tem tipo de média de artefacto)
E0144
cached signature bundle does not match its recorded digest
A cached signature bundle does not match the digest recorded for it (Um bundle de assinatura em cache não corresponde ao digest registado para ele)
E0145
plugin reference is not a Plugin entity
A plugin reference is not a Plugin entity (Uma referência de plugin não é uma entidade Plugin)
E0146
circular reference expansion
A library reference expands into itself (Uma referência de biblioteca expande-se em si mesma)
E0147
registrytrust: advertised trust config is malformed
A registry serves a trust document that cannot be read as one (Um registo serve um documento de confiança que não pode ser lido como tal)
E0148
registrytrust: registry advertises no trust config
A registry publishes no trust document (Um registo não publica nenhum documento de confiança)
E0149
attachment name is a near miss for a declared slot
An attachment name is one edit from a declared slot (Um nome de anexo está a uma edição de distância de um slot declarado)
E0150
attachment does not conform to its declared slot shape
Attachment does not conform to its declared slot shape (O anexo não está em conformidade com a forma declarada do seu 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 (Um componente está colocado em mais de uma fronteira)
E0152
duplicate Aggregate/Manifest identity (metadata.name) in the Release directory
The Release directory declares one Aggregate or Manifest twice (O diretório da Release declara duas vezes um Aggregate ou um 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 (Uma funcionalidade anexada tanto pelo Aggregate como pela Release não pode ser fundida)
E0154
the compiler's own views of the catalog disagree
A guard needs a catalog entity the build resolved and cannot see (Uma guarda precisa de uma entidade do catálogo que a compilação resolveu e que ela não consegue ver)
E0155
duplicate delivery key across inject sources
Duplicate delivery key across inject sources (Chave de entrega duplicada entre as fontes 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 (A chave de inject não está entre o que o destino fornece)
E0158
invalid parameter reference: check the {{ .parameters.* }} expression names a declared parameter and parses as a Go template
A {{ .parameters.* }} reference cannot be interpolated (Uma referência a parâmetros não pode ser interpolada)
E0160
manifest annotation bindings collide on same Feature path+pillar
Two Manifest annotation bindings compete for one routing slot (Duas associações de anotação do Manifest competem por um mesmo slot de encaminhamento)
E0161
manifest annotation binding uses reserved prefix
A Manifest annotation binding claims the reserved aggrega.ai/ prefix (Uma associação de anotação do Manifest reivindica o prefixo reservado)
E0162
missing required feature: attach a Feature of the required type to the component
Required feature not attached (Funcionalidade obrigatória não anexada)
E0163
required uses socket not populated
Required uses: socket not populated (Socket obrigatório não preenchido)
E0164
parameter contract violated
Parameter type mismatch / contract violation (Tipo de parâmetro incompatível / violação de contrato)
E0165
required parameter not supplied
Parameter type mismatch / contract violation (Tipo de parâmetro incompatível / violação de contrato)
E0167
Recipe publishes a provides key its Component does not declare
A Recipe publishes a provides key its Component does not declare (Uma Recipe publica uma chave que o seu Component não declara)
E0168
authored pillar does not conform to its declared schema
Authored values or infra do not conform to the declared schema (Os values ou infra escritos não estão em conformidade com o esquema declarado)
E0169
self-inject on component without spec.inject allowlist
Self-inject on a component without an allowlist (Self-inject num componente sem lista de permissões); Self-inject mechanism not in the component’s allowlist (Mecanismo de self-inject fora da lista de permissões do componente)
E0170
aggregate/manifest reference unresolvable
A Release’s aggregate: or manifest: reference resolves to nothing (A referência de uma Release não se resolve em 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 não declarado no esquema de sockets da entidade proprietária)
A Release reached resolution without passing through the load path (Uma Release chegou à resolução sem passar pelo caminho de carregamento)
E0173
declared parameter is read by no reference in the Aggregate
A declared parameter is read by nothing (Um parâmetro declarado não é lido 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 (Um nome de socket está a uma edição de distância de um 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 (Um ficheiro não pode ser lido, ou os seus bytes não são analisáveis)
E0176
signing: keyless signing requires a live identity provider, Fulcio, and Rekor
Keyless signing was asked for without the services it needs (A assinatura sem chave foi pedida sem os serviços de que precisa)
E0177
signing: no signature found for an artifact that requires one
An artifact that must be signed carries no signature (Um artefacto que tem de estar assinado não traz nenhuma assinatura)
E0178
signing: keyless verification requires at least one trusted identity
A keyless trust policy names no acceptable signer (Uma política de confiança sem chave não nomeia nenhum signatário aceitável)
E0179
signing: signature does not verify
A detached signature does not verify against the key supplied (Uma assinatura destacada não é verificada com a chave fornecida)
E0180
signing: signature bundle does not verify
A signature does not verify (Uma assinatura não passa na verificação)
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 (Uma publicação não assinada tem como destino um registo ou uma política que exige uma assinatura)
E0182
signing: cannot load pinned trust root
The pinned trust root cannot be read (A raiz de confiança fixada não pode ser lida)
E0183
signing: registry requires signatures; refusing to push unsigned content
An unsigned publish targets a registry or a policy that requires a signature (Uma publicação não assinada tem como destino um registo ou uma política que exige uma assinatura)
E0184
signing: unsupported held-key type
A pinned verification key is not the key profile the verifier accepts (Uma chave de verificação fixada não é do perfil de chave que o verificador aceita)
E0185
signing: signature identity is not trusted for this registry
A signature verifies but its signer is not one the registry trusts (Uma assinatura passa na verificação, mas o seu signatário não é um em quem o registo confia)
E0186
no source adapter serves the source kind
A Recipe’s source: names a kind nothing knows how to acquire (A origem de uma Recipe designa um tipo que nada sabe como adquirir)
E0187
cacheslot: empty workspaceRoot
A source artifact is cached without a workspace root to anchor it (Um artefacto de origem é guardado em cache sem uma raiz do espaço de trabalho a que o ancorar)
E0188
artifacts entry: shape must be a string scalar or {$import: <local-path>}
An inline-or-import field is written in neither shape (Um campo inline ou de importação não está escrito em nenhuma das duas 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 (O corpo de uma entrada de biblioteca não tem a forma que essa biblioteca contém)
E0190
schemalibrary: forbidden JSON Schema keyword
A schema uses a JSON Schema keyword the library does not admit (Um esquema usa uma palavra-chave de JSON Schema que a biblioteca não admite)
E0191
mappinglibrary: entry body must be a string scalar
A library entry’s body is not the shape that library holds (O corpo de uma entrada de biblioteca não tem a forma que essa biblioteca contém)
E0192
a document nests too many levels deep
A document nests deeper than the reader will descend (Um documento aninha-se mais fundo do que o leitor desce)
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 (O bloco de parâmetros de uma Release não está escrito em nenhuma das suas duas formas)
E0194
schemalibrary: template not found
A $instantiate: reference cannot be resolved (Não é possível resolver uma referência)
E0195
schemalibrary: template parameter missing
A $instantiate: reference cannot be resolved (Não é possível resolver uma referência)
E0196
schemalibrary: template parameter type mismatch
A $instantiate: reference cannot be resolved (Não é possível resolver uma referência)
E0197
valuesmapping: shape must be a string scalar or {$import: <path-or-library-identity>}
An inline-or-import field is written in neither shape (Um campo inline ou de importação não está escrito em nenhuma das duas 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 (Um fornecedor declara uma anotação well-known num âmbito que não renderiza)
E0199
workloadlibrary: entry body must be a string scalar
A library entry’s body is not the shape that library holds (O corpo de uma entrada de biblioteca não tem a forma que essa biblioteca contém)
E0200
workload: shape must be a string scalar or {$import: <path-or-library-identity>}
An inline-or-import field is written in neither shape (Um campo inline ou de importação não está escrito em nenhuma das duas formas)
E0201
assertion name declared twice across the extends chain
An assertion name is declared twice along an extends: chain (Um nome de asserção é declarado duas vezes ao longo de uma cadeia de extensão)
E0202
cyclic extends chain
Cyclic extends chain (Cadeia extends cíclica); Cyclic extends on Components or Features (Extends cíclico em Components ou Features)
E0204
FeatureRecipe: valuesMapping requires source
A FeatureRecipe’s valuesMapping requires source (O mapeamento de valores de uma FeatureRecipe exige uma origem)
E0205
inheritance merge failed
An extends: chain cannot be assembled (Não é possível montar uma cadeia de extensão)
E0207
recipe output-component-labels constraint: key is also declared in outputLabels
A promoted component label is also declared literally (Uma etiqueta de componente promovida também é declarada literalmente)
E0208
recipe output-labels constraint: key uses a reserved namespace
An output-label key uses a reserved namespace (Uma chave de etiqueta de saída usa um espaço de nomes reservado)
E0209
Recipe: valuesMapping requires source
valuesMapping requires source (o mapeamento de valores requer uma origem)
E0210
Recipe: at least one input kind required
At least one input kind must be present (Tem de estar presente pelo menos um 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 (Colisão de nomes de ficheiro no momento da emissão entre tipos de entrada)
E0212
workload attachment slot is not referenceable
A Workload references a slot whose fill publishes no locator (Um Workload faz referência a um slot cujo preenchimento não publica nenhum localizador)
E0213
workload featuresSchema cross-check failed
A Workload attachment names a slot the entity does not declare, or a delivery the slot forbids (Um anexo de Workload indica um slot que a entidade não declara, ou uma entrega que o slot proíbe)
E0214
workload validation failed
A Workload does not satisfy the Workload schema (Um Workload não satisfaz o esquema Workload)
E0215
document envelope validation failed
YAML anchor aliased inside its own content (Âncora YAML referenciada por um alias dentro do seu próprio conteúdo); Divergent Release (extends + aggregate pointer) (Release divergente (extends + ponteiro aggregate))
An x-aggrega-when: or x-aggrega-validate: predicate cannot be evaluated (Não é possível avaliar um predicado)
E0218
validator/jsonschema: schema resolution failed
A declared schema cannot be resolved (Um esquema declarado não pode ser resolvido)
E0220
extends chain exceeds maximum depth
An extends: chain runs past the depth bound (Uma cadeia de extensão ultrapassa o limite de profundidade)
E0221
merger: invalid merge input
The schema-merge step’s own input guard (A salvaguarda de entrada própria do passo de fusão de esquemas)
E0222
registry alias matches more than one host
A registry alias matches more than one host (Um alias de registo corresponde a mais de um 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 (Uma associação de plugin define uma chave que o socket ao qual se anexa não lê)
E0224
workspace configuration is invalid
The workspace configuration is invalid (A configuração do espaço de trabalho é inválida)
E0225
capability is bound to more than one provider plugin
A capability is bound to more than one provider plugin (Uma capacidade está associada a mais de um plugin fornecedor)
E0226
registry alias is already used by another host
A registry alias is already bound to another host (Um alias de registo já está associado a outro 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 (Um anexo de governação não declara nenhum papel, ou declara um que não é um papel conhecido)
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 (Uma associação de plugin define uma chave que o socket ao qual se anexa não lê)
E0229
position out of range
An editor position falls outside the document (Uma posição do editor fica fora do 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 (O digest registado de um plugin fidedigno diverge do artefacto em cache)
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 (Um plugin registado como controlo fidedigno já não está anexado)
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 (Um plugin devolveu algo que não tem a estrutura que o socket lê)
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 (Um fornecedor nomeou para um contribuidor um diretório que não é um único diretório)
E0251
recipe source is an empty string, which names neither sourceless mode nor sourced mode
Recipe source: is an empty string (O campo source da Recipe é uma cadeia vazia)
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 (Um ficheiro de bundle de uma ArtifactLibrary não nomeia nenhum ficheiro próprio sob a chave em que foi importado)
E0253
annotation binding does not resolve against its target Feature
Annotation binding does not resolve against its target Feature (A associação de anotação não se resolve em relação à sua 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 (Um valor de anotação associado não está em conformidade com o esquema da 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 (Uma anotação é encaminhada por um pilar que o seu lado de autoria não pode usar)
E0256
annotation binding declares one path in both pillar lists
An annotation binding declares one path in both pillar lists (Uma associação de anotação declara um mesmo caminho em ambas as 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 (Um contrato de esquema declarado não pode ser lido 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 (Uma Feature de âmbito de fronteira está anexada apenas a um 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 (Um componente que a composição contém não está posicionado em nenhuma fronteira)
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 (Uma fronteira nomeia um componente que a composição não contém)
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 (A identidade do Component não pode ser carimbada no que ele 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 (O destino não aceita um nome derivado de uma identidade escrita)
E0264
provider guest never accepted a component identity the compiler composed for it
A provider never accepted a name the compiler composed (Um fornecedor nunca aceitou um nome composto pelo compilador)
E0265
provider does not support the node's input kind
workload: requires a provider that can synthesize (requer um fornecedor capaz de sintetizar)
E0266
a schema `$import:` could not be applied
A schema $import: cannot be applied (Uma importação de esquema não pode ser aplicada)
E0267
a schema block declares a key that names no data pillar
A schema block names a key that is not a data pillar (Um bloco de esquema nomeia uma chave que não é um pilar de dados)
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 (A remontagem de um fornecedor recebe uma unidade que o seu próprio recorte nunca produziu)
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 (Um fornecedor devolveu dois ficheiros de saída sob um mesmo caminho)
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 (A cablagem de ligação de um fornecedor nomeia um ficheiro de saída que nunca foi emitido)
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 (A emissão de ficheiro de um passo de pipeline não traz nenhum ficheiro)
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 (Um passo de pipeline declara um tipo de emissão que o contrato não 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 (Um template lê um nome renderizado que o fornecedor do nó não comunica)
E0274
the plugin identity recorded as trusted no longer matches what this resolution reports
A gate recorded as trusted resolves to a different identity (Um controlo registado como fidedigno resolve-se para uma identidade 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 (Uma edição produziria um documento que o seu esquema recusa)
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 (A alteração em publicação viola o que a rubrica de evolução permite)
E0277
an annotation key on the entity uses a prefix the platform reserves
An annotation key uses a prefix the platform reserves (Uma chave de anotação usa um prefixo que a 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 (O nome de uma entidade não segue a forma que o seu tipo espera)
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 (Um esquema usa uma referência dinâmica que não pode ser resolvida antecipadamente)
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 (Um esquema declara um identificador que pertence à 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 (A etiqueta de categoria de um Component e o seu diretório indicam categorias diferentes)
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 (Uma extensão de esquema é escrita diretamente no conteúdo do 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 (Um Plugin não fixa nenhum dos dois limites de execução, pelo que se aplicam os da 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 (Um slot de anexo admite apenas material secreto sem dizer que o trata)
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 (Uma Recipe publica uma chave que o seu Component não declara, com verificação na publicação)
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 (A versão oferecida é um incremento menor do que a alteração exige)
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 (Uma importação parou a meio da tradução de uma origem)
E0288
a plugin has no expression for a construct this build declares
A workload declares a form compose cannot express (Uma carga de trabalho declara uma forma que compose não consegue exprimir); A container declares a field compose has no primitive for (Um contentor declara um campo para o qual compose não tem primitiva); An omits entry names a kind or a namespace a compose file does not have (Uma entrada omits nomeia um kind ou um namespace que um ficheiro compose não tem); An omits entry names a namespace a CloudFormation template does not have (Uma entrada omits nomeia um namespace que um template CloudFormation não tem); A rule reads a bound CloudFormation parameter by name (Uma regra lê pelo nome um parâmetro do CloudFormation associado); The assembled CloudFormation stack cannot carry a transform (A stack do CloudFormation montada não consegue transportar uma transformação)
E0289
a plugin could not resolve something it requires to exactly one value
A health probe cannot be turned into a compose healthcheck (Uma sonda de integridade não pode ser transformada num healthcheck do compose); A configmap volume has no file behind it (Um volume configmap não tem nenhum ficheiro por trás); What an omits entry left out is still named by the compose file (Aquilo que uma entrada omits deixou de fora ainda é nomeado pelo ficheiro compose); What an omits entry left out is still named by a CloudFormation template (Aquilo que uma entrada omits deixou de fora ainda é nomeado por um template CloudFormation); A valuesMapping key names no parameter of a sourced CloudFormation template (Uma chave de valuesMapping não nomeia nenhum parâmetro de um template CloudFormation de origem); Another component references a CloudFormation parameter a sourced template’s binding filled (Outro componente referencia um parâmetro do CloudFormation que a associação de um template de origem preencheu); Two components order one pair of transforms oppositely (Dois componentes ordenam um mesmo par de transformações de forma oposta); A cross-boundary reference has no consuming stack to be written into (Uma referência entre fronteiras não tem nenhuma stack consumidora onde ser escrita); A synthesized StatefulSet has no single service to govern it (Um StatefulSet sintetizado não tem um único serviço que o governe)
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 (Um nome de exportação escrito é um que a compilação deriva para uma referência entre stacks); The output a cross-stack reference publishes on already carries an Export (A saída na qual uma referência entre stacks publica já traz um Export); Two entries reach one stack output name (Duas entradas chegam a um mesmo nome de saída da stack); A CloudFormation fragment writes one key twice (Um fragmento do CloudFormation escreve uma mesma chave duas vezes); Two rendered resources land at one output file (Dois recursos renderizados vão parar a um mesmo ficheiro de saída)
E0291
a plugin has no representation for a value it was given
A published port declares a transport compose cannot spell (Uma porta publicada declara um transporte que o compose não consegue escrever); A resources quantity cannot be converted to a compose value (Uma quantidade de recursos não pode ser convertida num valor do compose); A resource quantity the helm provider emits is not a quantity (Uma quantidade de recurso que o fornecedor helm emite não é uma quantidade); A service type the helm provider cannot render (Um tipo de serviço que o fornecedor helm não consegue renderizar); A Kubernetes version the helm provider cannot render a chart for (Uma versão do Kubernetes para a qual o fornecedor helm não consegue renderizar um chart); A value bound to a CloudFormation parameter cannot take the parameter’s type (Um valor associado a um parâmetro do CloudFormation não pode assumir o tipo do parâmetro); A value bound to a CloudFormation parameter is one its constraints refuse (Um valor associado a um parâmetro do CloudFormation é um que as suas restrições recusam); A secret bound to a CloudFormation parameter would be written into the template (Um segredo associado a um parâmetro do CloudFormation seria escrito no template); A dynamic reference is bound where CloudFormation does not resolve it (Uma referência dinâmica está associada onde o CloudFormation não a resolve); A cross-boundary reference was spliced into a longer string (Uma referência entre fronteiras foi inserida numa string mais longa)
E0292
a plugin reported a failure that none of the declared kinds names
A plugin reported a failure it did not classify (Um plugin comunicou uma falha que não classificou)
E0293
wasm: guest plugin named a condition the socket does not declare
A plugin named a condition the socket does not declare (Um plugin nomeou uma condição que o socket não 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 (Dois subsistemas declaram um componente com um mesmo nome)
E0295
library reference: a reference to a library entry carries no whitespace or line break
A reference to a library entry carries whitespace (Uma referência a uma entrada de biblioteca contém espaços em branco)
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 (Os elos de uma cadeia de Release divergem quanto à estrutura de encaminhamento)
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 (Uma Release filha herda um diretório de fronteira que se resolve onde a sua Release pai escreve)
E0298
oci: published bundle carries no entity document
A published bundle holds no entity, or holds two (Um bundle publicado não contém nenhuma entidade, ou contém duas)
E0299
oci: published bundle carries more than one entity document
A published bundle holds no entity, or holds two (Um bundle publicado não contém nenhuma entidade, ou contém duas)
E0300
oci: published bundle cannot be unpacked
A published artifact cannot be read as an entity (Um artefacto publicado não pode ser lido como uma entidade)
E0301
oci: published artifact is not an entity document
A published artifact cannot be read as an entity (Um artefacto publicado não pode ser lido como uma entidade)
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 (Uma entidade lê uma entrada para a qual o lock ao lado dela não regista nenhuma fixação)
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 (Uma entidade partilha o seu diretório com outra entidade)
E0304
a path names content outside the entity's own directory
A path names content outside the entity’s own directory (Um caminho designa conteúdo fora do diretório da própria entidade)
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 (Uma origem local já não corresponde às fixações registadas ao lado da sua Recipe)
E0306
plugin artifact not found on this machine
A plugin’s .wasm is not on this machine (O ficheiro Wasm de um plugin não está nesta 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 (Um valor colocaria um ficheiro em cache fora da cache)
E0308
a Feature reaches a component alongside a Feature it declares a conflict with
Two Features declared to conflict reach one component (Duas Features declaradas em conflito alcançam um mesmo componente)
E0309
a symbolic link sits among the files an entity carries
A symbolic link sits among the files an entity carries (Uma ligação simbólica está entre os ficheiros que uma entidade transporta)
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 (Um registo é adicionado offline sem uma política de confiança a fixar)
E0311
reference carries a malformed version pin
A version pin is none of the forms a pin takes (Uma fixação de versão não tem nenhuma das formas que uma fixação assume)
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 (Uma associação de fornecedor nomeia uma capacidade que contém dois pontos)
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 (Uma associação de fornecedor nomeia uma capacidade que nenhum plugin lido pela compilação serve)
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 (Um plugin foi construído a partir de uma árvore de trabalho com alterações sem commit)
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 (Uma ligação traz um anexo sob um nome para o qual o seu socket não declara nenhum 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 (Um anexo da Release toma o nome do anexo de uma ligação)
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 (Um anexo de ligação da Release não nomeia nenhum 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 (Duas Features anexadas entregam uma mesma chave, a posterior através do injectMapping da sua FeatureRecipe)
E0319
connection alias is already used by another connection of the same component
Two connections of one component under one alias (Duas ligações de um componente sob um mesmo 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 (Um caminho que a operação escreve conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar)
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 (Um ficheiro que a operação lê conduz, através de uma ligação, para fora do diretório dentro do qual tem de ficar)
E0323
template reads its callers' render facts, but the FeatureRecipe does not set readsCallerRenderFacts
A template reads its callers’ render facts without declaring it (Um template lê os factos de renderização dos seus chamadores sem o declarar)
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 (Uma referência a outro ficheiro sai do diretório dentro do qual deve 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 (Um fornecedor comunicou um facto de renderização cujo valor não é uma 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 (Um passo de pipeline lê os factos de renderização dos seus chamadores)
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 (Um template indexa um mapa com uma chave que o mapa não contém)
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 (Um anexo escrito sob outro nome encaixa num slot que o seu componente deixa vazio)
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 (Uma ligação e o destino que alcança não indicam uma mesma chave)
E0330
signing: the references named together need different signing credentials, so nothing was signed
References signed together need different signing credentials (Referências assinadas em conjunto precisam de credenciais de assinatura diferentes)
E0331
signing: no verified signature is recorded for an artifact that requires one
No verified signature is recorded for an artifact that requires one (Nenhuma assinatura verificada está registada para um artefacto que exige uma)
E0332
signing: the recorded signature was made for a different artifact
A recorded signature was made for a different artifact (Uma assinatura registada foi feita para um 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 (Uma assinatura registada não é a que um pull registaria)
E0334
an omits entry left out nothing the source rendered
An omits entry left out nothing the source rendered (Uma entrada omits não deixou de fora nada do que a fonte renderizou)
E0335
provider does not support omits
The provider does not support omits (O fornecedor não suporta 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 (As contagens de omissões de um fornecedor não correspondem às entradas omits que recebeu)
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 (Uma entrada fixa uma versão do seu importador que o catálogo não contém)
E0338
importer is attached by more than one plugins.importer entry
An importer is attached by more than one plugins.importer entry (Um importador está anexado por mais de uma entrada)
E0339
more than one importer recognises the source
More than one importer recognises the source (Mais de um importador reconhece a origem)
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 (Um nome que a operação escreve contém uma parte que o Windows não consegue conter)
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 (Um importador que não declara padrões de ficheiro recebe um diretório)
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 (Nenhum ficheiro do diretório corresponde aos padrões de ficheiro do importador)
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 (Um ficheiro lido do diretório e um ficheiro nomeado nas origens do importador têm o mesmo nome)
E0344
an entry this publication carries cannot be used on Windows
A published archive carries an entry Windows cannot use (Um arquivo publicado traz uma entrada que o Windows não consegue usar)
E0345
a container declares one environment variable twice
A container gives one environment variable two values (Um contentor dá dois valores a uma mesma variável de ambiente)
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 (A anotação de métricas de um Component e a sua chave provides divergem)
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 (Um template lê os factos de renderização dos seus destinos sem o declarar)
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 (Um passo de pipeline lê os factos de renderização dos seus 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 (O destino de uma importação nomeia uma capacidade à qual nenhuma Recipe do catálogo se associa)
E0350
no importer recognises the source
No importer recognises the source (Nenhum importador reconhece a origem)
E0351
provider does not support boundary artifacts
The provider does not support boundary artifacts (O fornecedor não suporta artefactos de fronteira)
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 (O diretório de saída de uma fronteira não é um diretório sob a raiz de saída)
E0353
boundary-level Feature instance name is not a directory name
A boundary-level Feature is named . or .. (Uma Feature de âmbito de fronteira chama-se . ou ..)
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 (Um template fez mais do que copiar um valor que leu de uma ligação entre fronteiras)
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 (Uma entrega de inject não é uma lista de entradas)
E0356
suspend requires form: scheduled
A workload suspend: is set on a form other than scheduled (A suspensão de uma carga de trabalho está definida numa forma diferente da agendada)
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 (Um mapeamento por nome do Manifest não nomeia nada na compilação)
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 (Um destino de aresta nomeia um componente de um módulo que o módulo não 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 (Nenhum adaptador de origem está registado neste programa para um tipo de origem)
E0360
the netrc file could not be read
The netrc file cannot be read (O ficheiro netrc não pode ser lido)
E0361
the source URL carries a credential
A source URL carries a credential (Um URL de origem contém uma 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 (Uma entrada de inject numa ligação traz um literal)
E0363
annotation subkey is not routed by the annotation's binding
An annotation subkey is not routed by its binding (Uma subchave de anotação não é encaminhada pela sua associação)
E0364
a value template failed while it ran
A value template failed while it ran (Um template de valores falhou durante a execução)
E0365
boundary-level Feature's output is routed to a dispatch path nothing assembles
A boundary-level Feature’s output reaches no assembled file (A saída de uma Feature de âmbito de fronteira não chega a nenhum ficheiro montado)
E0366
FeatureRecipe injectMapping output could not be read as a dictionary of deliveries
An attached Feature’s injectMapping output cannot be read (A saída injectMapping de uma Feature associada não pode ser lida)
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 (Um valor de anotação simples não é encaminhado para exatamente um caminho da sua associação)
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 (A saída injectMapping de uma Feature associada escreve entregas sob uma chave 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 (Um template lê e itera um caminho que não contém nada)
E0370
a pipeline declares one step id twice
A pipeline declares one step id twice (Um pipeline declara duas vezes o mesmo id de passo)
E0371
catalog document declares a kind a catalog does not hold
A catalog document declares a kind a catalog does not hold (Um documento de catálogo declara um tipo que um catálogo não contém)
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 (Uma entrada de injeção numa Feature anexada contém um literal)
E0373
a document declares an API version this compiler no longer reads
A document declares an API version this compiler no longer reads (Um documento declara uma versão de API que este compilador já não lê)
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 (Um plugin declara uma versão da ABI de plugins que este compilador já não suporta)
E0375
oci: artifact carries a media type this compiler no longer reads
An artifact carries a media type this compiler no longer reads (Um artefacto contém um tipo de média que este compilador já não lê)
E0376
egress: the server did not answer in time
A server did not answer in time (Um servidor não respondeu a tempo)
E0377
registry: the repository listing did not end in time
A registry’s repository listing did not end in time (A listagem de repositórios de um registo não terminou a tempo)
E0378
oci: the registry kept asking to slow down
A registry kept asking to slow down (Um registo continuou a pedir para abrandar)
O domínio do linter (não fatal)
O compilador mantém-se estritamente sem opiniões próprias quanto à execução. Nunca interrompe a compilação por padrões que são apenas suspeitos — valores não utilizados, segredos órfãos, destinos desligados. No máximo, um padrão destes origina um aviso — o da própria compilação, para os poucos catalogados acima em «Condições que não interrompem uma compilação», como um parâmetro declarado que nada lê — e o resto pertence ao domínio do linter, onde as empresas optam por adotar plugins Wasm que aplicam as suas próprias convenções.
Credenciais órfãs
Uma Feature de credenciais anexada sem um contrato de entrega inject: não é um erro de compilação. O compilador central preserva a declaração no grafo IR e não emite nenhum aviso. Os plugins linter empresariais podem detetar este padrão e alertar para ele; os renderizadores empresariais também podem optar por montar implicitamente os segredos órfãos segundo as suas próprias convenções Black-Box. Como ambas as interpretações são válidas, o compilador central não toma partido por nenhuma.