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

Conventions de nommage

Ce chapitre couvre les règles de nommage et de casse qui s’appliquent au contenu Aggrega rédigé : le modèle des noms d’instance rédigés par l’utilisateur, la discipline de casse des noms de champs dans le DSL, la casse que la plateforme utilise pour les identifiants qu’elle définit à votre place, et la syntaxe des commentaires utilisée sur la surface de rédaction YAML.

Noms d’instance

Les noms d’instance écrits par l’utilisateur — les clés que le développeur écrit pour les composants, les features, les agrégats, les sous-systèmes, les frontières, ainsi que les sockets et alias uses — suivent tous un même motif : ^[a-zA-Z0-9_-]+$. Le kebab-case (pii-filter, my-agent) comme le snake_case (openai_key, db_credentials) sont valides ; les équipes peuvent adopter la convention qu’elles préfèrent.

Caractères autorisés : alphanumériques (a-z, A-Z, 0-9), traits d’union (-) et tirets bas (_). Aucun autre caractère n’est permis.

Exemples :

components:
web-server: # kebab-case
finance_worker: # snake_case
features:
pii-filter: # kebab-case
audit_logger: # snake_case
openai_key: # snake_case — natural for a credential attachment
db-password: # kebab-case — also valid
MotifPortéeExemples
^[a-zA-Z0-9_-]+$Tous les noms d’instance écrits par l’utilisateurweb-server, openai_key, pii-filter

Le motif est appliqué lors de la résolution via patternProperties de JSON Schema.

Ce que coûte un nom de composant, et pourquoi les majuscules coûtent plus cher sous certaines cibles

Le motif ci-dessus indique ce que vous pouvez écrire. Ce qu’un nom coûte est une autre question, et la réponse dépend de la cible sur laquelle un composant est déployé : mieux vaut donc le savoir avant de choisir un nom plutôt qu’au moment où un build en refuse un.

Le nom d’un composant devient l’identité dont est marquée chaque ressource qu’il émet, et chaque cible dérive ses propres noms de cette identité : un installeur de charts en dérive un nom de release, un orchestrateur de conteneurs en dérive des noms de service. Une cible dont l’alphabet est plus restreint que le motif ne peut pas porter un caractère qu’elle n’admet pas, et Aggrega ne ramènera pas silencieusement un tel caractère à un caractère semblable : deux noms qu’un auteur sait distinguer ne doivent pas devenir un seul nom dans un cluster. Un caractère que la cible n’admet pas est donc écrit sous forme de séquence d’échappement, et une séquence d’échappement est plus longue que le caractère qu’elle remplace.

La conséquence pratique : une lettre majuscule est gratuite sous certaines cibles et coûteuse sous d’autres.

  • Sous une cible dont les noms admettent les majuscules — un fichier compose d’orchestration de conteneurs, par exemple — PaymentsAPI est repris exactement tel que vous l’avez écrit et coûte onze caractères.
  • Sous une cible dont les noms sont uniquement en minuscules — le nom de release d’un installeur de charts — chaque majuscule est échappée, et un nom composé de six majuscules seulement dépasse déjà ce que cette cible accepte.

Il existe un second effet, et c’est le plus marqué : une séquence d’échappement commence par un trait d’union. Une cible qui exige qu’un nom commence par une lettre minuscule ou un chiffre refusera donc un nom dont le premier caractère est un caractère qu’elle n’admet pas, aussi court que soit le reste — aucun raccourcissement n’y remédie.

Les recommandations découlent de ces deux effets. Privilégiez les lettres minuscules et les chiffres, avec des traits d’union entre les mots, et commencez un nom par une lettre minuscule. payments-api est repris inchangé par chaque cible pour laquelle Aggrega fournit un provider. payments_api est repris par un fichier compose, mais pas par la cible helm, dont les noms de ressource n’admettent pas le tiret bas : les Services, les workloads et la release qu’elle nomme d’après le composant s’écrivent payments-zuapi. PaymentsAPI y coûte plus cher encore. Une Recipe qui publie l’adresse d’une telle ressource lit l’orthographe propre à la cible au lieu de la prédire — voir templates/rendered-resource-names.md.

Un chiffre initial peut légalement être écrit et ne coûte rien sous un fichier compose, mais la cible helm le refuse. Un nom de Service Kubernetes doit commencer par une lettre, et les Services qu’émet un chart ou un workload synthétisé portent le nom du composant ; un composant nommé 1cache arrête donc un build helm — le refus nomme le composant et indique qu’un nom de Service doit commencer par une lettre — au lieu de produire des Services que le cluster refuserait.

Rien de tout cela n’est une règle que le compilateur applique de sa propre initiative : il ne détient les règles de nommage d’aucune cible et n’invente aucune limite. Le provider de chaque cible répond de ses propres noms ; un nom n’est donc refusé que lorsque la cible sur laquelle un composant est effectivement déployé déclare ne pas pouvoir l’utiliser, et le refus porte la raison propre à cette cible et pointe vers la clé spec.components que vous avez écrite. Un nom accepté sous une cible et refusé sous une autre constitue le comportement attendu, et non une incohérence.

Les noms qu’Aggrega compose lui-même — l’identité d’une feature attachée à une frontière, par exemple — sont traités à l’inverse : ils sont raccourcis pour tenir dans la cible au lieu d’être refusés, car ils sont assemblés à partir de parties écrites à plusieurs endroits et aucun auteur ne peut à lui seul voir la longueur qu’ils atteignent. Seul un nom que vous avez écrit est refusé.

Le point comme séparateur de chemin réservé

Le caractère point (.) est exclu de tous les noms d’instance écrits par l’utilisateur. Le point sert de séparateur de chemin généré par le compilateur pour les références de composants entre agrégats.

Lorsqu’un Aggregate racine importe un sous-agrégat nommé data-layer contenant un composant nommé main-db, le compilateur construit l’ID absolu aplati data-layer.main-db en joignant par un point le nom d’instance de l’agrégat et le nom d’instance du composant. Ce chemin pointé apparaît dans :

  • Les cibles uses du développeur : target: data-layer.public_db — référence à un composant exporté depuis un agrégat imbriqué.
  • Les diagnostics propres au build : un arrêt ou un avertissement concernant ce composant le nomme par son chemin pointé, de sorte que le nom que vous lisez est celui que vous pouvez rechercher dans vos documents.

Le séparateur n’atteint pas un nom

Un chemin pointé est une adresse à l’intérieur de vos documents, et ce n’est pas un nom qu’une cible de déploiement acceptera. Un nom de Service Kubernetes n’admet aucun point ; pire, un point à l’intérieur d’une adresse de cluster est ce qui sépare un service du namespace dans lequel il se trouve, si bien qu’un nom pointé transmis à un consommateur comme hôte se résoudrait vers un autre service au lieu d’échouer.

Le séparateur est donc réécrit dans chaque nom et chaque label que le build dérive de l’identité d’un composant, et il est réécrit plutôt que remplacé : data-layer.main-db devient data-layer-zdmain-db. Le remplacer par un caractère qu’une cible accepte permettrait à deux composants différents d’aboutir au même nom — data-layer.main-db et un composant que quelqu’un a écrit data-layer-main-db — et un nom auquel aboutissent deux composants n’identifie ni l’un ni l’autre.

Ce que cela atteint, et ce que cela n’atteint pas :

  • Cela atteint les noms et les labels dérivés de l’identité — metadata.name sur une ressource qu’Aggrega synthétise, les labels aggrega.ai/component-id et app.kubernetes.io/name, les sélecteurs qui leur correspondent, les noms de fichiers émis, {{ .context.instance_id }} et le nom qu’un provider dérive pour lui-même, comme un nom de release helm. Ils évoluent ensemble, de sorte qu’une adresse qu’une Recipe compose à partir de la clé qui nomme une ressource — .context.instance_id là où la cible la nomme d’après l’identité, .context.rendered_name là où la cible signale un nom qui lui est propre — nomme toujours la ressource que le build émet.
  • Cela n’atteint pas un nom que vous avez écrit. Un nom de composant ne contenant aucun séparateur revient octet pour octet, de sorte que seul un composant apporté par un Aggregate importé s’écrit différemment dans la sortie et dans le document.
  • Cela n’atteint pas les noms à l’intérieur d’un chart ou d’un fragment fourni par un auteur. Ils appartiennent à qui les a écrits, et un nom repris d’un chart tiers — un nom de ressource personnalisée de la forme <plural>.<group>, où le point est légal — est émis exactement tel que ce chart l’a écrit.

🔴 Ce dernier point a une conséquence sur ce qu’une Recipe doit publier, et c’est l’erreur la plus facile à commettre sur cette page. Les templates propres à un chart fourni nomment leurs ressources d’après l’identité que la plateforme leur transmet — un nom de release, écrit dans l’alphabet propre à cette plateforme plutôt que dans celui décrit ci-dessus — et la cible helm nomme les workloads qu’elle synthétise d’après ce même nom de release. Ainsi, pour une sortie produite à partir de sources que vous avez fournies, et pour un workload synthétisé sous une telle cible, {{ .context.instance_id }} n’est pas le nom que portent ces ressources, et une adresse publiée à partir de lui ne nomme rien dès que les deux alphabets diffèrent. La clé qui porte le nom de la plateforme, et les providers qui en signalent un, sont décrits dans templates/rendered-resource-names.md.

Réécrire le séparateur coûte des caractères, et un nom de longueur limitée peut en manquer. Le séparateur est remplacé par une courte séquence d’échappement plutôt que par un seul caractère, de sorte qu’une identité qualifiée, une fois écrite, est un peu plus longue qu’elle n’apparaît dans vos documents. Cela n’a d’importance que là où le nom qu’elle devient est limité : la cible qui produit un composant indique la longueur de valeur de label qu’elle accepte, et là où l’identité écrite la dépasserait, le build s’arrête au lieu d’émettre une valeur que la cible rejetterait. L’arrêt indique la longueur dans laquelle l’identité elle-même doit tenir — la longueur avant la réécriture, de sorte qu’un nom choisi dans cette limite fonctionne du premier coup — et la correction consiste à raccourcir les parties écrites par l’auteur : le nom que le document importateur donne au sous-agrégat, ou le nom propre du composant qu’il contient.

Le séparateur est la raison habituelle pour laquelle un nom s’écrit plus long qu’il ne se lit, mais ce n’est pas la seule. Deux formes qu’un nom écrit par l’auteur peut légalement prendre ne peuvent pas non plus être reprises telles quelles, car les laisser rendrait une séquence d’échappement ambiguë : un nom se terminant par un trait d’union, et un nom dont un trait d’union est immédiatement suivi de z. Chacune est réécrite de la même manière, au même coût. Tout autre nom écrit par l’auteur revient octet pour octet ; un nom composé de lettres, de chiffres, de tirets bas et de traits d’union entre les mots n’est donc concerné par rien de tout cela.

Un nom de socket dans le bloc uses propre à un composant correspond soit à une clé du usesSchema de l’entité de catalogue — un socket déclaré —, soit à un socket ad hoc du développeur lui-même, qui se compile même sur une entité qui ne déclare aucun usesSchema ; un nom situé à une seule modification d’un socket déclaré déclenche un avertissement qui nomme les deux graphies. Le uses par arête d’une Release, et celui d’un attachement de Feature, ne peuvent nommer qu’un socket que l’entité déclare, et tout autre nom échoue avec une erreur de validation unknown-uses-socket.

Casse des champs

Le DSL sépare le YAML destiné aux développeurs (écrit par des humains) des contrats internes du compilateur (consommés par les templates et les outils) :

  • YAML destiné aux développeurs (camelCase) : les noms de champ composés de plusieurs mots dans les schémas Aggregate, Release, Component, Feature, Recipe, FeatureRecipe, Manifest et Plugin utilisent le camelCase. Exemples : exportedComponents, syncWave, subDirectory, featuresSchema, usesSchema, valuesMapping, injectMapping, executionScope, appliesTo, appliesToAnyOf, conflictsWith. Suit les conventions de l’API Kubernetes.
  • Contrats internes (snake_case) : les noms de champ composés de plusieurs mots dans le schéma de l’IR Graph et dans le schéma du Template Context utilisent le snake_case. Exemples visibles par l’utilisateur que rencontrent les auteurs de Recipe : instance_id (dans .context.instance_id — l’identité de la Recipe), inject_raw (dans .inject_raw, un pilier de premier niveau à côté de .inject plutôt qu’une clé sous .context — le contrat d’injection non modifié), attachment_name (dans le contexte d’une FeatureRecipe d’attachement — indique le slot que l’attachement remplit, ou le nom sous lequel il a été attaché). Suit les conventions de JSON API et s’aligne sur la génération des tags de struct JSON de Go.
  • Champs d’un seul mot : en minuscules quel que soit le contexte. Exemples : values, infra, inject, provides, locals, features, labels, annotations, boundaries, components, subsystems, pipeline, source.

Les développeurs ne rencontrent pas le snake_case dans le YAML qu’ils écrivent, et les auteurs de templates ne rencontrent pas le camelCase dans leurs templates Go. Les ajouts au schéma suivent ces conventions.

Trois casses qui se croisent dans une même instruction

L’écriture de Recipes croise couramment les trois conventions de casse dans une même instruction : le champ DSL défini par le schéma utilise le camelCase, le nom d’instance écrit par l’utilisateur utilise le kebab-case ou le snake_case, et la référence au contexte de template utilise le snake_case. Les auteurs qui repèrent ces croisements comme des conventions distinctes lisent sans peine le YAML obtenu ; ceux qui tentent de ramener les casses à une seule convention peinent avec les frontières.

L’exemple canonique : le template valuesMapping: d’une Recipe qui référence l’instance de Component produite via le contexte de template.

# Recipe authored against a Component the developer instantiated as "web-server"
# (kebab-case instance name) in their Aggregate.
spec:
valuesMapping: | # camelCase — schema-defined DSL field
name: "{{ .context.instance_id }}" # snake_case — template context
# internal contract
image: "{{ .values.image }}" # snake_case — template context
# internal contract

Trois casses, une instruction :

  • valuesMapping — camelCase. Le nom de champ DSL que le schéma définit pour le template de mapping de la Recipe. Camel parce que le YAML du langage destiné aux développeurs suit les conventions de l’API Kubernetes.
  • web-server (référencé indirectement via le composant produit) — kebab-case. Le nom d’instance écrit par l’utilisateur dans l’Aggregate ; le développeur a choisi la forme avec trait d’union. Pourrait tout aussi bien être web_server (snake_case) ; les deux sont valides selon le motif des noms d’instance.
  • instance_id, image — snake_case. Noms de champ à l’intérieur du contexte de template (.context.instance_id, .values.image). Snake parce que l’IR Graph et le contexte de template suivent les conventions JSON-API et s’alignent sur la génération des tags de struct JSON de Go.

Les trois casses ne sont pas interchangeables. Un auteur de Recipe qui écrit {{ .context.instanceId }} (camelCase) arrête le build : .context déclare ses clés, et instanceId n’en fait pas partie ; la référence est donc refusée avant tout rendu, et le diagnostic liste les clés que .context définit — voir errors/fatal-halts.md « Template references a root the render context does not define (Le template référence une racine que le contexte de rendu ne définit pas) ». Un développeur qui écrit web.server (avec un point) se heurte au rejet du motif des noms d’instance, car le point est réservé comme séparateur de chemin. L’objectif de cette discipline : gardez les trois conventions à l’esprit lorsque vous lisez ou écrivez ; appuyez-vous sur les frontières (l’endroit où vous vous trouvez dans le YAML ou le template) pour savoir quelle casse s’applique.

Identifiants définis par la plateforme

Tout ce qui précède régit les noms sur la surface d’écriture — un nom d’instance que vous choisissez, un champ de schéma que le langage définit pour que vous le renseigniez, une clé du contexte de template que vous lisez. Deux autres registres régissent les identifiants que la plateforme elle-même définit et que vous ne faites que relire ou saisir. Ils sont distincts parce qu’ils remplissent des fonctions différentes, et c’est la fonction qui décide de la forme.

Le registre descriptif : kebab-case, uniformément. Un identifiant de ce registre dit en mots ce qu’il nomme, de sorte que vous pouvez le lire et agir en conséquence sans rien chercher. Un flag de CLI, l’id d’une règle de lint de publication, un code de classe de diagnostic et le code sous lequel une condition d’arrêt est enregistrée en font tous partie.

--no-unsupported-field-warnings # a CLI flag you type
category-matches-directory # a lint rule id, printed in `aggrega lint` output
unsupported-field # a diagnostic class code
artifact-provenance-skipped # another
parameter-contract-violation # the code a halting condition is registered under

Lorsqu’une classe de diagnostic possède un flag de suppression, le code et le flag sont les mêmes mots dans le même ordre — unsupported-field est réduit au silence par --no-unsupported-field-warnings — de sorte que la classe que vous avez reconnue vous indique le flag à utiliser, sans rien à traduire. Un code de classe est le nom stable sur lequel les outils s’appuient pour reconnaître un constat sans analyser le texte de son message ; la formulation du message peut s’améliorer, le code ne bouge pas.

Le registre des codes courts : la lettre E et quatre chiffres. Une condition d’arrêt porte aussi un code court — E0007 — et c’est le seul identifiant défini par la plateforme qui n’est pas en kebab-case. La raison en est sa position : il ouvre chaque diagnostic d’arrêt, à côté de la catégorie, avant le fichier et la ligne que vous allez lire.

[DEVELOPER_ERROR E0007] aggregate.yaml at .spec.components.edge

Un code descriptif ne peut pas se trouver là. Le plus long d’entre eux remplirait à lui seul un terminal étroit, avant l’emplacement qui vous indique où regarder. L’en-tête prend donc un identifiant choisi pour sa largeur, et ce compromis est délibéré : quatre chiffres ne disent rien d’une condition, c’est pourquoi chaque code court est publié à côté de la condition qu’il nomme et du texte sous lequel cette condition s’affiche dans la référence des sentinelles d’erreur. Citez un code court dans un rapport, saisissez-le dans une recherche et résolvez-le là.

Les deux registres nomment les mêmes conditions depuis deux directions, et aucun ne remplace l’autre. Utilisez le code descriptif lorsque vous écrivez un outil qui s’appuie sur une condition ; citez le code court lorsque vous parlez d’une condition à une personne.

Le kebab-case qui apparaît ici et dans les noms d’instance n’est pas une collision. Le motif des noms d’instance porte sur ce que vous êtes autorisé à écrire — le kebab-case et le snake_case y sont tous deux valides, et les équipes en choisissent un. Ce registre porte sur ce que la plateforme écrit, là où il n’y a rien à choisir : vous ne choisissez jamais l’orthographe de l’id d’une règle de lint, et la plateforme ne choisit jamais l’orthographe du nom de votre composant.

Il laisse les casses des champs inchangées. Les champs de schéma écrits par l’auteur restent en camelCase et les clés du contexte de template restent en snake_case. Aucun des identifiants de ce registre n’est un champ sur l’une ou l’autre surface — ce sont des noms courts et stables pour un flag, une règle ou une classe de constats — de sorte qu’un code de diagnostic en kebab-case ne dit rien de l’orthographe d’un champ de schéma.

Discipline des suffixes dans le nommage des chemins de document

Un sous-ensemble de champs du langage porte des valeurs de chemin de document — des chaînes qui pointent vers une position à l’intérieur d’un autre document (la section volumes d’un Workload produit, l’entrée featuresSchema d’un Component, le niveau mappings d’un Manifest). Les valeurs suivent la syntaxe RFC 6901 JSON Pointer — des jetons séparés par des barres obliques qui identifient le chemin à travers le document cible.

RFC 6901 est la grammaire de chemin de référence pour chaque surface de chemin de document dans Aggrega. Le contrat des plugins Wasm consomme des documents JSON Patch RFC 6902 dont les chemins sont des pointeurs RFC 6901 (selon la sortie JSONPatch du rôle label-transform dans plugins/plugin-contract.md) ; l’inventaire des chaînes de format de la grammaire URI cite RFC 6901 aux côtés de la syntaxe des templates Go et des helpers Sprig (selon vocabulary/uri-grammar.md « Format-string inventory ») ; les exports .locals de chaque Recipe utilisent RFC 6901 pour pointer vers les positions du Workload synthétisé que les plugins Wasm Injector reçoivent dans le pipeline de plugins par le biais du payload with de leur étape. Une seule grammaire, plusieurs surfaces qui la consomment.

La discipline des suffixes de nommage distingue les deux côtés d’écriture de ces valeurs de chemin par une répartition délibérée des suffixes, alignée sur la section plus générale « Casse des champs » ci-dessus :

  • Les champs de schéma qui portent des JSON Pointers RFC 6901 utilisent le suffixe camelCase *Path. Ces champs font partie du schéma YAML destiné aux développeurs ; ils suivent donc la convention camelCase. Aucun schéma d’entité ne déclare un tel champ ; les chemins de document qu’écrit un auteur sont les clés d’export .locals ci-dessous.
  • Les clés d’export .locals qui portent des JSON Pointers RFC 6901 utilisent le suffixe snake_case *_path. Ces clés font partie de la surface d’export interne de la Recipe — lues par les templates suivants de la Recipe elle-même, et par un pipeline de plugins Wasm via le payload pipeline[].with qui référence .locals — elles suivent donc la convention snake_case. Exemples :
    • volumes_path — .locals.volumes_path: "/spec/template/spec/volumes" expose la position du tableau volumes du Workload synthétisé.
    • containers_path — .locals.containers_path: "/spec/template/spec/containers" expose la position du tableau containers.
    • resource_path — .locals.resource_path: "/resource/aws_s3_bucket/main" expose un chemin de ressource natif Terraform.
    • root_path — .locals.root_path: "/data" expose le chemin racine que consomme le pipe du moteur de rendu.

Les deux conventions de suffixe reflètent la convention à deux niveaux de la section « Casse des champs » : les champs définis par le schéma utilisent le camelCase ; les identifiants écrits par l’utilisateur ou privés à la Recipe utilisent le snake_case (ou le kebab-case). La discipline des suffixes *Path / *_path rend visible au niveau de l’identifiant la nature de grammaire de chemin de la valeur — un lecteur qui voit l’un ou l’autre suffixe sait que la valeur suit la syntaxe RFC 6901 sans avoir à inspecter la valeur elle-même.

Exemple détaillé : un Wasm Injector qui consomme les exports *_path d’une Recipe.

# Recipe (Domain 3) — declares .locals exports the Wasm Injector consumes
spec:
locals:
primary_compute: "worker-container"
containers_path: "/spec/template/spec/containers"
volumes_path: "/spec/template/spec/volumes"
# Credential FeatureRecipe (Domain 3) — attached to the component the Recipe
# above realizes. Its templates read `.locals`: an attachment sees the host
# Recipe's resolved locals merged with the attachment's own block.
spec:
pipeline:
- id: workload_injector
plugin: pipeline-step/k8s-workload-injector:2.0.0
function: inject_secret
with: |
target_container: "{{ .locals.primary_compute }}"
containers_path: "{{ .locals.containers_path }}"
volumes_path: "{{ .locals.volumes_path }}"

Les clés *_path sont des exports privés à la Recipe ; les valeurs containers_path / volumes_path sont des chaînes JSON Pointer RFC 6901. Le plugin Injector consomme ces chaînes pour positionner sa sortie JSONPatch par rapport à l’AST du Workload produit. L’attachement les atteint sur son propre pilier .locals — il n’existe pas de champ .context.uses[].locals, de sorte qu’un consommateur ne peut pas lire les locals de sa cible à travers une arête uses ; ce qui traverse une arête, c’est le provides de la cible.

Pour l’inventaire plus large des chaînes de format (syntaxe des templates Go, fonctions Sprig, JSON Pointer aux côtés des regex SemVer et de la grammaire des sélecteurs de labels), voir vocabulary/uri-grammar.md « Format-string inventory ». Pour la surface du contrat des plugins Wasm qui consomme des patchs RFC 6902 adressés par des pointeurs RFC 6901, voir plugins/plugin-contract.md.

Syntaxe des commentaires

Les caractères de commentaire dépendent du langage environnant :

  • Contexte YAML (la surface d’écriture par défaut de toute entité Aggrega) : utilisez #
  • Contexte de template Go (à l’intérieur des scalaires de bloc valuesMapping: d’une Recipe, des scalaires de bloc injectMapping: d’une FeatureRecipe, des entrées de mapping d’une MappingLibrary, des corps assertions: des blocs d’assertions) : utilisez {{/* ... */}} pour les commentaires de template que le moteur de templates reconnaît et supprime au moment du rendu, ou # pour les commentaires de niveau YAML en dehors du corps du template.

Les schémas en forme compacte sous schema:, usesSchema:, featuresSchema: et parameters: sont entièrement en YAML ; l’annotation description: par champ est la surface documentée pour la documentation en ligne des champs (port: { type: integer, description: "TCP listen port" }).