Saltar a contenido

Las páginas sin traducir se abren en inglés y se indican como inglés.

Esta página es una traducción automática de la página en inglés, que prevalece. Machine-translated from the English page, which is authoritative.

Celdas

La memoria de un despliegue puede crecer más allá de un primario de Postgres y un servicio de ClickHouse, y una organización puede querer su memoria en servicios propios. Una celda es un despliegue completo de Loom tal como lo describe esta documentación: sus réplicas y workers, una unidad de Postgres (un primario con sus standbys), un servicio de ClickHouse, un prefijo de bucket de documentos, su propio host público, y sus propias claves de firma, concesiones, workers y borrado. Un router en el host compartido del despliegue envía cada solicitud a la celda que contiene lo que esta direcciona. Una organización vive en exactamente una celda, la que la colocó, y nunca la abandona. Una organización se coloca al hacer attach (las organizaciones que la celda contenía y sus organizaciones configuradas), con loom cell update (una organización configurada que cambió) o loom cell place, o en la primera solicitud verificada de un principal limitado a ella. Un despliegue con una sola celda y sin router funciona como un despliegue único.

Las celdas necesitan la autoridad de Postgres (LOOM_STORAGE_AUTHORITY=postgres) y una autenticación que todos los transportes apliquen (auth_actually_required(), y que LOOM_MCP_AUTH_MODE no sea open): loom cell attach se niega a continuar sin ellas, y un proceso con LOOM_CELL definido se niega a arrancar sin ellas. Autoridad de almacenamiento describe qué contiene una celda y cómo concuerdan sus dos almacenes.

Por qué despliegues completos

Una celda no comparte almacén, clave, lease ni worker con otra. Todas las garantías que ofrece un despliegue individual (aislamiento entre tenants, una revocación que se aplica de inmediato, cobertura de borrado, un lease de worker, una cadena de auditoría, una restauración) se cumplen por celda sin cambios, y los datos, las concesiones y el borrado de una organización nunca abarcan varias celdas. El router añade el directorio y las reglas de enrutamiento que se describen más abajo; cada celda añade una comprobación de que contiene la organización a la que se dirige una solicitud.

Lo que abarca varias organizaciones pasa a ser por celda:

  • un token es válido en la celda que lo emitió y en ninguna otra;
  • las filas de todo el despliegue son por celda: la lista negra global (org='*'), la configuración y las sobrescrituras en tiempo de ejecución, las reglas de políticas, las sobrescrituras de límites de tasa y de presupuesto, la rotación de claves de firma y la revocación de un sujeto. loom cell each -- <command> ejecuta un comando de administración sin organización en cada celda con una credencial de corta duración por celda, registra el resultado de cada celda, reanuda las celdas que fallaron y falla hasta que todas tengan éxito; loom doctor compara la configuración de las celdas y las huellas de configuración e indica qué difiere;
  • las organizaciones de código y de tracker (LOOM_CODE_ORG, LOOM_TRACKER_ORG) son propias de cada celda: cada celda indexa sus propios repositorios, con el costo de ingesta de cada uno;
  • la vista de plataforma de un operador y el panel son por celda, en el host de la celda.

El router

El router es un proxy HTTP sin estado, que se ejecuta como varias réplicas detrás del host compartido del despliegue, se publica por separado y admite celdas de las compilaciones N-1 y N. Guarda el directorio en su propia base de datos Postgres:

  • cells: la celda, su host público, los emisores de tokens bearer que solo ella acepta (su propio LOOM_JWT_ISSUER, sus LOOM_JWT_TRUSTED_ISSUERS, sus emisores de usuarios finales), sus almacenes (su id de despliegue y el nombre y prefijo del bucket), su estado (attaching, serving), cuándo empezó el attach (attach_started_at, que attach escribe bajo el bloqueo del directorio solo después de superar todas sus negativas, antes de escribir cualquier fila en la celda que no sea sus sondeos y las revocaciones de --revoke-unprovisioned, y que un attach reanudado lee), su modo de tenencia y cuándo se fijó (prepare escribe el primero, y attach registra cada uno que sube o intenta subir), si está cerrada a nuevas organizaciones y su cuota de ubicaciones (placements_max), el SHA-256 de la credencial con la que llama al router (current y, durante una rotación, next), la huella de su secreto raíz (keys_fp), su probe_url (la del propio router para la primera celda), los nombres y huellas de clave de sus bots de emergencia (break-glass), y la huella de su configuración (current y, durante un cambio, next; los campos nombrados en «Comprobado de forma continua»), que attach y loom cell update escriben junto con la copia propia de la celda de esa huella (loom.cell_self);
  • placements: organización, celda. Una fila por organización, escrita una sola vez y nunca borrada;
  • hosts: el host de cada celda y los alias del host compartido (abajo).

El router tiene su propia credencial de operador, definida en su configuración y nunca en el directorio; todo cambio del directorio por parte del operador se hace con ella, y todo cambio, incluidas las ubicaciones, se escribe en el registro de auditoría del router. Adjuntar una celda requiere además una credencial de administrador de la plataforma de la celda que se adjunta. El router informa de su propia liveness y readiness, aparte de las de cualquier celda.

El router se coloca primero delante del despliegue existente, al que pasa todas las solicitudes; ese despliegue se convierte en la primera celda cuando se adjunta, y conserva el host compartido como host propio, de modo que sus clientes, tokens, tokens de actualización, clientes OAuth y callbacks registrados siguen funcionando. El router responde por sí mismo en sus propias rutas (/cells/, /livez, /readyz) y enruta todo lo demás, incluidas las rutas /v1/health de una celda, tanto a celdas attaching como serving, en este orden:

  1. Por host. Una solicitud al host propio de otra celda va a esa celda. El host compartido, y cualquier alias suyo registrado en hosts, son configuración propia del router y se tratan con las reglas 2 a 4 (la celda de la regla 4 es el upstream de paso, antes de registrar la primera celda y después, ya que prepare la registra en esa dirección), sin responder nunca 421; cualquier otro host que ninguna fila de cells nombre responde 421. Cada URL que entrega una celda nombra su propio host: sus endpoints OAuth y OIDC, el URI de verificación del device flow, el callback de inicio de sesión (LOOM_OAUTH_ISSUER, registrado en el proveedor de identidad por celda), su JWKS, las páginas y recursos del panel, y los metadatos de recurso MCP. Los clientes MCP de una celda distinta de la primera usan el host de la celda, que imprimen las líneas de configuración de la celda.
  2. SCIM se enruta por host, como la regla 1: la aplicación del proveedor de identidad de cada celda lo aprovisiona en su propio host (abajo); SCIM en el host compartido es el de la primera celda, salvo una solicitud /scim/v2/Groups con un JWT, que va por su emisor como en la regla 3. Las rutas de Groups se comprueban contra la tenencia (escriben loom.principal_groups de la organización).
  3. Por emisor. Una solicitud con token al host compartido va a la única celda que acepta su claim iss, leído sin verificar; la celda verifica. Un emisor que ninguna celda acepta responde 401. Hasta que la primera celda esté serving, las reglas 2 a 4 envían toda solicitud del host compartido a la celda de la regla 4, que la verifica, de modo que el despliegue detrás del router atiende las organizaciones que contiene como antes durante prepare, el despliegue de LOOM_CELL y attach; desde el despliegue hasta serving, una organización nueva necesita además el directorio en cada proceso con LOOM_CELL definido (responde 503 ahí mientras el directorio no se pueda leer). Esto cubre MCP y toda op, sea cual sea la organización que nombre un cuerpo, y los tokens de los emisores federados y de usuarios finales de las integraciones.
  4. Todo lo demás en el host compartido va a la primera celda: sus flujos OAuth y de dispositivo, las actualizaciones, los callbacks, las solicitudes de contraseña y de autorregistro, los sondeos de salud y la página de inicio de sesión; la revocación de un token (/oauth/revoke) de un JWT va por su emisor, como en la regla 3, y la de un token de actualización opaco va a la primera celda, ya que solo los clientes de la primera celda usan el host compartido (loom logout revoca en el host en el que inició sesión). Los documentos de descubrimiento del host compartido son los de la primera celda.

El router llega a una celda en el upstream_url que registra su fila del directorio, una dirección dentro de la red del despliegue (la de la primera celda es LOOM_ROUTER_UPSTREAM_URL, escrita por prepare, de modo que registrarla no cambia ninguna ruta; la de una celda posterior la escribe su attach), nunca en el host público de la celda, que nombra al propio router; antes de registrar la primera celda, la celda de la regla 4 es el despliegue delante del cual se colocó (LOOM_ROUTER_UPSTREAM_URL). El host compartido es LOOM_ROUTER_SHARED_HOST, el host propio de la primera celda y los alias de esa celda en hosts. Reenvía cada solicitud tal como la envió el cliente (su ruta y consulta en bruto, su propio Host) con la vista propia del router de la dirección, el esquema y el host del cliente en X-Forwarded-For, -Proto y -Host, reemplazando lo que el cliente afirme ahí (por eso cada celda lista las direcciones del router en LOOM_TRUSTED_PROXIES, o cuenta a cada cliente como el router para sus límites de inicio de sesión y lee el esquema como el del router), descarta las cabeceras que describen una sola conexión (y las que nombra Connection), conserva cada línea de cabecera de la respuesta (incluido un segundo Set-Cookie), transmite ambos cuerpos en streaming (incluido un flujo de eventos enviados por el servidor), responde 502 cuando no se puede llegar a la celda, y nunca reenvía una ruta bajo /cells/ (la que no sirve responde 404). Una primera celda registrada sin dirección upstream responde 503, como la de cualquier celda. Lee las celdas, sus emisores y hosts una vez por LOOM_ROUTER_DIRECTORY_CACHE_S, respondiendo desde la última tabla mientras se vuelve a leer una obsoleta en segundo plano, de modo que un directorio que se cuelga o no se puede leer no retrasa ninguna solicitud; antes de su primera lectura, responde 503. Un emisor que dos celdas listan (lo que attach rechaza) no se enruta a ninguna.

Un cliente encuentra la celda de una organización con GET /cells/lookup?org=<org>, sin autenticación y con límite de tasa; una organización sin ubicación responde la primera celda con el mismo cuerpo que una organización ubicada allí (solo se almacena en caché la respuesta de una organización ubicada, así que los tiempos y una caída aún pueden distinguirlas: el nombre de una organización no es un secreto), y antes de registrar ninguna celda la búsqueda responde 503 con el código NO_CELL; un directorio que no puede leer para una organización que no tiene en caché responde 503 con BACKEND_UNAVAILABLE. Un cliente compara el código, nunca el mensaje: ante NO_CELL, y ante un 404 de un despliegue sin router, loom login --org conserva el host que se le dio (el host compartido, atendido como antes por la regla 4, o el despliegue único); ante un 429 espera el Retry-After y pregunta de nuevo, durante un máximo de --wait (2 minutos por defecto), y luego se niega como rechazo por tasa; ante cualquier otra respuesta se niega, nombrando al router, de modo que ningún flujo comienza en una celda que quizá no contenga la organización. La celda de una organización es pública, como la URL de un espacio de trabajo: la búsqueda revela que existe una organización fuera de la primera celda. loom login --org, la página de inicio de sesión de la primera celda (que pide primero la organización) y las líneas de configuración inician cada flujo OAuth, de dispositivo y de inicio de sesión en el host de la celda de la organización, de modo que ningún flujo cruza celdas; un navegador solo se redirige al inicio de un flujo nuevo.

Solo la primera celda está alguna vez en recording: una celda cuya fila first es (false, …) trata cualquier modo que no sea enforced como enforced en sus triggers de organización, su caché de modo y su CLI, de modo que la fila de modo de una celda posterior fijada en recording no registra nada. Una celda en recording lee su propio estado con GET /cells/v1/cells/<cell>, con su credencial del router, que solo se responde para la celda que el índice único del directorio nombra primero y solo se acepta cuando el SHA-256 de la credencial es uno de los hashes que el directorio registra para <cell>, dentro de LOOM_CELL_ROUTER_TIMEOUT_S (5 s por defecto, el tiempo de espera de la llamada de ubicación); una respuesta rechazada, fallida o tardía cuenta como ilegible.

Con el directorio inaccesible, las reglas 1 a 4 enrutan desde las celdas en caché del router; una búsqueda de una organización que no tiene en caché y una ubicación responden 503.

Las rutas del operador, cada una con la credencial de operador del router, están bajo /cells/v1/operator/cells/<cell>: limit, credential y register (el de prepare), la propia fila (GET, con el nombre de cualquier otra fila, que attach lee para sus negativas, su comprobación de finalización y su reanudación), el attach de la primera celda (attach/begin, attach/place, attach/enforced y attach/serving, en ese orden) y DELETE. Cada una salvo register responde 404 con el código NO_SUCH_CELL a una celda que el directorio no contiene, de modo que un 404 sin él indica una réplica del router de una compilación anterior. Toda llamada que tiene éxito, la lectura incluida, se escribe en el registro de auditoría (la repetición de un registro, que no cambia nada, no escribe ninguna), y toda llamada ejecuta un número fijo de sentencias, cada una acotada por el statement timeout del directorio (aplicado también en el servidor del directorio); la lectura y la eliminación llevan los límites derivados que espera loom cell. Todo cambio toma el bloqueo del directorio y luego el bloqueo de fila de la celda (el orden que siguen el registro, los cambios del operador y la eliminación). Cada réplica del router ejecuta una compilación con estas rutas antes de que comience el attach de una primera celda: la ubicación de una compilación anterior choca con la de un lote de attach como un 503 transitorio, y su registro puede añadir una celda posterior a mitad de un attach, algo que toda llamada de attach rechaza entonces hasta que se elimina. Cada llamada de attach se niega salvo que la fila sea la de la primera celda, esté attaching, y registra el id de despliegue que nombra la llamada, y mientras exista cualquier otra fila (el registro rechaza una celda posterior hasta que la primera esté serving, y una réplica del router de una compilación anterior aún podría registrar una):

  • attach/begin lleva las huellas de la celda exactamente como las almacena loom.cell_self, la huella de su secreto raíz, las listas de permitidos con las que attach juzgó los almacenes y nonces nuevos. Rechaza una huella cuyo id de despliegue, bucket, prefijo, host público o host del emisor difieran de los de la fila (se rechaza un host del emisor distinto del propio de la celda), y una cuyo cuerpo de ubicación en vivo, con un nombre de organización en su longitud máxima, superaría el límite de cuerpo del router, nombrando los campos más grandes. Fuera de toda transacción del directorio ejecuta el sondeo del registro en el probe_url de la fila y pide al upstream_url de la fila el id de despliegue, de modo que los almacenes que lee attach son los desde los que sirve la celda en vivo. Luego, bajo los bloqueos, escribe attach_started_at una sola vez, las huellas solo mientras la fila no tenga ninguna (otras huellas ahí responden 409: cambian con loom cell update) y keys_fp en cada llamada, y audita las listas de permitidos. Es idempotente. Su cuerpo tiene su propio límite, 256 KiB, a partir del cual responde 413.
  • attach/place ubica un lote de como máximo 500 organizaciones (dentro del límite de cuerpo de 64 KiB) una vez que begin se ha ejecutado y el modo del directorio es enforced, más allá de la marca de cierre y la cuota de la celda: el lote contiene organizaciones que la celda ya atiende, así que se cuenta pero nunca se rechaza por el estado de cerrada ni por la cuota, a diferencia de una ubicación en vivo o la de una celda posterior. Ejecuta un número fijo de sentencias: una inserción del lote que omite una organización ya ubicada, una lectura que rechaza el lote (revertido, nombrando la organización) cuando una organización está ubicada en otra celda, un recuento, y una fila de auditoría por organización que ubicó y una por la llamada. Una ubicación en vivo de la misma organización se ejecuta en paralelo una vez que el modo es enforced; ambas mantienen el bloqueo de fila de la celda, una ubicación en vivo vuelve a leer al ganador una vez que lo tiene, y cada inserción omite una organización ya ubicada y cuenta solo lo que escribió, de modo que la organización se ubica y se cuenta una sola vez.
  • attach/enforced registra el modo enforced del directorio, tras lo cual la primera celda ubica las organizaciones nuevas en vivo; es idempotente.
  • attach/serving vuelve a ejecutar el sondeo y la comprobación del upstream y luego, bajo los bloqueos, calcula los emisores de la fila a partir de sus huellas (bearer_issuers de current y next) y marca la celda como serving; en una celda serving responde de inmediato, con auditoría. begin, place y enforced en una celda serving responden 409.

DELETE elimina la fila de una celda que está attaching sin ubicaciones, sea cual sea su modo de directorio, junto con sus filas de hosts, con auditoría: una primera celda se deshace hasta su primera ubicación, y una celda posterior registrada por una compilación anterior deja de bloquear el primer attach. Una ubicación en curso o bien se confirma primero y la eliminación se rechaza, o bien no encuentra fila. El router no puede leer los almacenes de la celda, por lo que loom cell remove, que lo llama, comprueba primero el Postgres de una primera celda (Operaciones).

SCIM e inicio de sesión entre celdas

Cada celda es su propia aplicación en el proveedor de identidad: un cliente OIDC para el inicio de sesión en su host y una aplicación SCIM que aprovisiona su /scim/v2, ambas asignadas al mismo grupo de personas, las personas de las organizaciones de esa celda. Una persona que el proveedor de identidad desactiva, elimina o desasigna se desaprovisiona en cada celda a cuya aplicación estuviera asignada; Loom no puede ver una aplicación configurada para admitir a personas sin asignar u omitir la desactivación al desasignar, por lo que el operador configura cada aplicación para exigir asignación y desactivar al desasignar. Cada celda conserva sus usuarios SCIM, desactivaciones y tombstones exactamente igual que un despliegue único (SSO y SCIM); el router no guarda ninguna identidad.

Una celda en enforced con SCIM activado exige SCIM: una persona actúa en la celda solo mientras su SCIM tenga una fila activa para ella. La comprobación se hace sobre la cuenta de la persona, no sobre cómo se escriba un sujeto: scim.refuses_subject(subject) toma las grafías de correo propias del sujeto y los correos de contacto y verificados de las cuentas activas que posee, incluidas las cuentas con contraseña, y rechaza si alguno de ellos no tiene una fila activa (la fila cuyo id es scim.user_id(email); una fila inactiva o eliminada con ese id siempre rechaza, y un correo sin fila propia solo pasa como dirección de trabajo de una fila activa cuyo correo principal sea una de las grafías propias del sujeto). Un principal fuera de SCIM es uno de una lista cerrada: un bot (un sujeto cuyo sa:<name> anterior a cualquier : posterior nombra una fila de loom.machine_identities: el bot y sus agentes, tal como lo analiza check_acted_for), un sujeto de máquina o de carga de trabajo, un usuario final (user:). Cualquier otro sujeto sa:, una cuenta de servicio personal, se comprueba a través de su creador (service_accounts.sa_creator) y de cada sujeto que liste el lineage de su fila, de modo que actuar en su nombre es actuar por la persona que la creó; cualquier otro sujeto en estas rutas es una persona, y se rechaza a menos que tenga una grafía de correo o posea una cuenta con una. Una lectura de SCIM que falla lanza SignInUnavailable, igual que scim.deactivated, nunca un OAuthError, de modo que un refresh devuelve su token y ninguna sesión termina por una caída. Todas las rutas que admiten a una persona lo usan:

  • un inicio de sesión SSO, antes de encontrar o crear la cuenta (JIT), con el correo que el proveedor de identidad verificó;
  • cada refresh de una sesión (_refresh_session), con el correo verificado que guarda el grant o, para un grant sin él, las cuentas del sujeto;
  • una actuación en nombre de una persona (authz.check_acted_for), sea cual sea la grafía del sujeto;
  • el sujeto de un token de gateway, comprobado al verificarse y recordado igual que las demás respuestas de la verificación;
  • el creador de un token delegado o de una cuenta de servicio personal (authz._check_creator), almacenado en caché igual que la comprobación de actuación en nombre de otro, de modo que un token creado por una persona nunca aprovisionada se rechaza una vez que la celda está en enforced.

SCIM activado ya cierra el inicio de sesión con contraseña y el autorregistro (oauth_login_provider=oidc), y el device flow inicia sesión mediante SSO, por lo que pasa por la misma comprobación. Los principales sin correo quedan fuera de SCIM y los desaprovisiona quien los creó: los bots y los tokens emitidos por un operador, los usuarios de emisores de usuarios finales por el servicio que firma por ellos, la confianza de carga de trabajo por su regla.

Break-glass. Cada celda tiene un bot de administrador de plataforma con prueba de clave (loom bot create --platform-admin), que no tiene correo y que SCIM nunca revoca, y un segundo, independiente, para attach y loom cell each. Sus claves permanecen en el almacén de secretos del operador, leídas en cada uso; el directorio registra solo el nombre de cada bot y la huella de su clave, de modo que el router no guarda ninguna credencial de celda, y cada uso del bot break-glass queda en el registro de auditoría de la celda y lo señala loom doctor. Los operadores están asignados a las aplicaciones de todas las celdas para el panel, y llegan a una celda cuya aplicación del proveedor de identidad esté rota a través de su bot.

Los tokens SCIM de una celda son suyos por construcción. El nombre de una celda coincide con [a-z0-9-]{1,32} (sin _, comparado exactamente; se impone en prepare, attach y arranque, y es único en el directorio). Un token que empieza por lsc_ nombra una celda y debe coincidir por completo con lsc_[a-z0-9-]{1,32}_[0-9a-f]{32,}, o todas las celdas lo rechazan; solo un token sin ese prefijo no nombra ninguna celda. Con LOOM_CELL definido, un token SCIM tiene la forma lsc_<cell>_<secret>, tal como lo genera loom cell scim-token new --cell <name> (se ejecuta sin conexión): exactamente tres campos separados por _, el del medio igual a LOOM_CELL, y un secreto de al menos 32 caracteres hexadecimales en minúscula (128 bits).

Un analizador junto a scim.tokens() devuelve el nombre de celda de un token o nada, y quienes lo llaman comparan eso con LOOM_CELL y con la fila first de la celda (más abajo). scim_settings_problem recibe ambos, de modo que el arranque y loom doctor rechazan mediante una sola función, y con LOOM_CELL definido rechazan un tercer token configurado (dos permiten una rotación). Una función, scim.authorized(presented), contiene la comparación en tiempo constante para ambas rutas SCIM (_authorized, scim_groups._caller). Con LOOM_CELL sin definir compara con los tokens configurados como lo hace un despliegue único y no lee nada. Con él definido compara con los tokens que el analizador admite para LOOM_CELL y la fila first; mientras esa fila no se haya leído lanza una excepción como AuthUnavailable, de modo que las rutas responden 503 con Retry-After y el proveedor de identidad reintenta.

  • Un proceso se niega a arrancar con un token SCIM que nombra otra celda, y /scim/v2 responde 401 ante uno.
  • Una celda posterior rechaza un token que no nombra ninguna celda. La primera celda, que conserva el host compartido, también acepta sus tokens existentes sin nombre, solo mientras su fila first sea (true, LOOM_CELL), de modo que su SCIM sigue funcionando durante el cambio sin rotación.
  • Un token copiado en la configuración de otra celda, o una aplicación del proveedor de identidad apuntada al host de la celda equivocada, por tanto falla de forma cerrada, y ninguna celda compara nunca sus tokens con los de otra.

Preparar una celda

loom cell prepare registra una celda en el directorio y escribe las filas que leen los procesos de la celda. La comprobación de tenencia (más abajo) indica qué escribe y cómo se reanuda; esta sección indica cómo demuestra que se le dio la celda correcta.

Cuál es la primera celda nunca es un ajuste ni el orden de preparación. Prepare lo concede solo a la celda cuyo host es el host compartido del router y cuyo id de despliegue es el que informa el upstream de paso del router en la dirección de sondeo del upstream. Esa dirección es la configuración propia del router (LOOM_ROUTER_UPSTREAM_PROBE_URL) y el probe_url de la primera celda, nunca uno de los argumentos de prepare: el router la lee ahí en cada prepare y cada reejecución, y rechaza una respuesta con otro id de despliegue o sin ninguno. El router también consulta el puerto principal de su upstream de paso (LOOM_ROUTER_UPSTREAM_URL, que el registro copia en la fila) y rechaza uno que informe otro id de despliegue, de modo que la fila nunca nombre dos despliegues. Prepare rechaza cualquier otra celda hasta que la primera esté registrada y en serving, bajo el bloqueo del directorio, de modo que ninguna celda posterior aparezca mientras la primera se adjunta.

Los almacenes son los activos. Antes de escribir nada, prepare escribe un nonce aleatorio en el Postgres de destino, bajo una clave reservada de loom._migration_lock del ClickHouse de destino, y como objeto de sondeo bajo el prefijo del bucket de destino. La ruta de sondeo de la celda debe devolver cada uno tal como lo lee desde su propia conexión al primario en esa petición. Después los nonces se eliminan; sus filas no contienen memoria ni organización y están clasificadas como tales. Se rechaza una copia con el mismo id de despliegue. Prepare envía al router los tres nonces junto con el registro (POST /cells/v1/operator/cells/<cell>/register, con la credencial de operador); el router lee por sí mismo el listener de sondeo y registra la celda solo cuando este responde el id de despliegue de la celda, esos nonces, y el bucket y el prefijo que nombra el registro (de modo que uno que no nombre bucket no pueda pasar por una celda que lo tiene). El router responde un listener que excede su tasa (429) como PROBE_BUSY, y uno al que no puede llegar o que no puede leer un almacén, o un puerto principal de upstream de la primera celda al que aún no puede llegar, como PROBE_UNREACHABLE, ambos 503, y prepare espera por ellos dentro de --wait. Una reejecución cuyas direcciones difieran de las de la fila se rechaza antes del sondeo.

La ruta de sondeo, GET /v1/health/deployment, no requiere credencial y queda fuera de la compuerta de huella:

  • En el puerto principal responde solo el id de despliegue que cada proceso verificó al arrancar, guardado en memoria, sea cual sea el Host de la petición. No lee ningún almacén y no tiene límite de tasa, de modo que ninguna avalancha en el puerto principal bloquea la comprobación de host de attach.
  • Completa, con los valores bajo las claves de nonce reservadas de prepare, se sirve solo en un puerto de listener de sondeo aparte (LOOM_CELL_PROBE_PORT, 0 para desactivarlo; necesita la autoridad de Postgres y la autenticación activadas, y se enlaza a todas las direcciones del host): la fila de Postgres loom.cell_probe y la clave de KeeperMap, ambas llamadas cell-probe, y el objeto <prefix>/_cell_probe; también nombra el bucket y el prefijo bajo los que almacena. Ninguno de estos valores es secreto. Responde 429 pasada una tasa fija por proceso en ese listener.
  • Solo la dirección de sondeo de la celda (probe_url) apunta al listener: una dirección interna que ningún ingress expone y a la que el router nunca enruta, que el despliegue envía a todo proceso vivo, esté listo o no, de modo que prepare y attach alcancen un proceso que la compuerta mantiene como no listo.
  • El listener de sondeo del chart está desactivado por defecto y se activa, también en el despliegue existente, antes del primer loom cell prepare. Genera un Service en ese puerto que publica direcciones no listas y no cambia ninguna NetworkPolicy. Quién puede alcanzar el puerto lo decide la política de red del operador, como en el caso de ClickHouse: con la política propia del chart activada, que admite solo el puerto http, el operador añade una política que admita el puerto de sondeo desde los pods del router (el router sondea el registro de prepare) y desde donde se ejecuta la CLI (las políticas se suman), y sin ella cualquier pod puede alcanzarlo. Del mismo modo, la salida de la celda hacia la dirección de ubicación del router y hacia Postgres corresponde al operador, mediante networkPolicy.extraEgress donde la política del chart está activada.
  • Prepare reintenta los PROBE_BUSY y PROBE_UNREACHABLE del router (un listener que está arrancando no es alcanzable durante un tiempo), y attach y loom cell update --probe-url reintentan un 429 del listener que sondean, durante --wait como máximo (10 minutos por defecto), y luego lo nombran.

El probe_url de una celda posterior se entrega a prepare, normalizado (http o https, sin userinfo), y se acepta solo cuando informa el id de despliegue que prepare lee de los almacenes de destino; después attach comprueba que el host propio de la celda informe el mismo id. Prepare rechaza un argumento de dirección de sondeo para la primera celda. loom cell update --probe-url reemplaza el de una celda posterior bajo el bloqueo del directorio tras la misma comprobación y un nuevo eco de nonce. Las direcciones de sondeo y de upstream de la primera celda se copian de la configuración del router en el registro, y loom cell update las reemplaza desde ella, una vez que todas las réplicas del router ejecutan los valores nuevos, tras el mismo sondeo y una comprobación de que el nuevo upstream informa el id de despliegue de la celda. Una reejecución de prepare nunca mueve una dirección: se rechaza mientras la réplica del router a la que llega esté configurada con otras.

La fila first. Prepare escribe una fila first explícita e inmutable en el Postgres de cada celda (loom.cell_first: un trigger de fila rechaza su update y delete y un trigger de sentencia su truncate, ambos creados ENABLE ALWAYS y comprobados por attach y loom doctor igual que los triggers de organización), (true, <cell>) para la primera celda y (false, <cell>) para cualquier otra, en la misma transacción que el modo de tenencia, de modo que ninguna exista sin la otra. Leídas juntas, las dos filas dan uno de cuatro estados. Ambas ausentes sin fila de tenencia ni propia: abierto, el de un despliegue único, sin comprobación; un proceso con LOOM_CELL definido permanece no listo ahí (sin fila de modo). En una celda que el directorio registra, esto ocurre solo cuando su Postgres se restaura a un punto anterior a su prepare (se cierra con loom cell restore) o un prepare se detiene entre su registro y la escritura de su fila (se cierra con una reejecución de prepare), y entretanto los triggers y los procesos con LOOM_CELL sin definir permanecen abiertos, como en un despliegue nunca preparado, ya que el Postgres de la celda, que guarda su estado, no puede distinguir ambos casos (ClickHouse no guarda estado de celda: añadirlo haría que la ruta de escritura leyera un segundo almacén para la tenencia) y tal proceso nunca lee el directorio; donde todos los procesos tienen LOOM_CELL sin definir, que loom doctor lo nombre (lo cual lee el directorio y se entrega con attach) es la única señal. Una fila (true, …) con recording y la fila propia: la primera celda en grabación. Ambas presentes con la fila propia en otro caso: enforced, y el modo de una celda posterior se lee como enforced diga lo que diga su fila (sus triggers, su caché de modo y la CLI lo tratan así, y loom cell prepare nombra una fila que no lo sea). Una sola fila, ambas sin la fila propia, o ambas ausentes junto a una fila de tenencia o propia (los estados partial: alguna fila de estado presente pero no todas las filas first, de modo y propia), que prepare nunca deja: los triggers de organización, donde una celda los tiene, actúan como en enforced (un arranque no crea ninguno en ella), todo proceso queda con compuerta como ante una fila no leída, loom doctor lo nombra, y una reejecución de loom cell prepare reescribe las filas que faltan desde el directorio mientras la celda sigue en marcha. Un índice único en el directorio permite una sola primera celda, y el valor no contiene contenido de memoria y está clasificado como tal. Attach vuelve a comprobar el host y el id de despliegue. Un proceso lee el valor junto con el modo, y «aún no leído», «ausente» y «falso» son distintos: solo una fila que se ha leído deja listo a un proceso, y una fila cuya celda no es LOOM_CELL lo deja con compuerta (más abajo) y la informa scim_settings_problem. El arranque se rechaza solo por los ajustes (scim_settings_problem con la fila sin leer comprueba únicamente la forma del token frente a LOOM_CELL); la comparación con la fila first se ejecuta por petición una vez leída la fila, y loom doctor lee el valor del Postgres de la celda o lo informa como desconocido.

La fila propia de la celda

Se comprueba de forma continua, no solo al hacer attach. Cada proceso calcula la huella de su configuración: campos con nombre bajo una versión de esquema (los hosts de su LOOM_PUBLIC_BASE_URL y del LOOM_OAUTH_ISSUER resuelto, su emisor OIDC y su client id, si SCIM está activado, los emisores bearer que acepta (trusted_issuers() y sus emisores de usuario final), sus orgs configuradas, las orgs de su jwt_end_user_issuers_json, el id de despliegue que verificó al arrancar, y el nombre y el prefijo del bucket). Su Postgres y su ClickHouse llevan ambos el id de despliegue (la comprobación de emparejamiento que ya ejecuta un despliegue único). El bucket, cuando hay uno configurado, se identifica por su nombre y prefijo (una celda sin bucket no participa en ninguna comprobación de bucket), y ningún par de celdas los comparte en ningún endpoint: el prefijo de ninguna celda en un bucket del mismo nombre queda anidado dentro del de otra ni lo contiene, de modo que un endpoint tomado del entorno no puede caer en el prefijo de otra celda. Ningún almacén se identifica por su dirección, así que un standby reemplazado, una conmutación por error, una dirección tomada del entorno o una restauración a un nuevo endpoint no cambian nada de lo que la celda comprueba. El id de despliegue, el nombre del bucket y el prefijo nunca cambian después de prepare: loom cell update rechaza un cambio en cualquiera de ellos, incluido añadir un bucket a una celda preparada sin él, y mover los datos de una celda a otros almacenes, o añadir uno, es un diseño aparte (Operaciones). Los bots no forman parte de ella: loom bot create los añade en tiempo de ejecución, cada uno con una org, y la ubicación ya los acota. La fila propia de la celda en loom.cell_self contiene una huella aceptada, current, y durante un cambio una segunda, next. Sus filas, y el heartbeat de la celda (loom.cell_heartbeats, con clave en la fila loom.instances del proceso y escrito junto con ella, ya que una tabla KeeperMap no admite columnas nuevas: el LOOM_CELL con el que se ejecuta, el estado que produce su última lectura, su huella y las claves que la acompañan), no contienen contenido de memoria y se clasifican así para el borrado. Un proceso coincide con un valor cuando todos los campos que ambos conocen son iguales, y un campo que falta en el valor cuenta como igual solo en su valor por defecto, de modo que las compilaciones N y N+1 con la misma configuración coinciden con una sola fila. Con LOOM_CELL definido, mientras la fila propia de su celda, la fila first o la fila de modo no se hayan leído, las filas de estado estén en estado partial (la regla de la fila first, arriba), la fila propia de la celda no exista o no coincida con ninguno de los dos valores, o la fila first nombre a otra celda, toda solicitud que reciba, salvo sus sondas de salud y la ruta de sondeo, responde 503 AuthUnavailable: las solicitudes bearer (la primera comprobación en verify_token, antes de la rama del emisor de usuario final), SCIM, y toda ruta que inicie sesión, emita, renueve o intercambie un token, incluidos el registro, los endpoints de OAuth y de dispositivo y el callback de inicio de sesión. También se declara no listo y se aparta de los workers como lo hace un proceso desviado: detiene sus pasadas, cede el lease y no nombra ningún lease en su fila de instancia, en todos los modos de LOOM_BACKGROUND_WORKERS (incluido on: sin lease que conservar, un proceso on de una celda ejecuta el bucle del lease, que inicia y detiene el supervisor según la puerta en un plazo de LOOM_TENANCY_MODE_CACHE_S más un periodo del bucle), y su fila de instancia no lo cuenta como en servicio, de modo que una compilación anterior a su lado mantiene los workers en marcha. Una lectura fallida conserva las últimas filas durante a lo sumo LOOM_JWT_REVOCATION_MAX_STALE_SECONDS, igual que el llavero de firma y la instantánea de revocación; pasado ese plazo el proceso queda bloqueado hasta que una lectura tenga éxito. El modo (más abajo) tiene el mismo límite. Una celda configurada para aceptar el emisor de otra celda, un host con el que no se hizo attach o un patrón de orgs que no se le concedió, por tanto, no sirve nada con ello, llegue la solicitud adonde llegue. Su heartbeat informa de la huella, el router rechaza una llamada de ubicación cuyos campos no coinciden con ninguno de los dos valores de la fila del directorio, y loom doctor señala una discrepancia, una celda cuyo cliente OIDC comparte otra celda, y una celda con SCIM desactivado junto a celdas con SCIM activado.

loom cell prepare escribe current en loom.cell_self junto con las filas first y de modo. Hasta que la fila del directorio contiene una huella (antes de attach), escribe, cuando falta la fila propia, la huella que informan en su heartbeat todos los procesos vivos, y se niega mientras algún proceso vivo ejecute una compilación anterior a N, que no informa ninguna, o mientras las huellas informadas difieran; una fila propia existente se mantiene, y un proceso vivo que ejecute ni su current ni su next provoca un rechazo; en cada ejecución, antes de registrarse, rechaza un proceso vivo cuyo id de despliegue, nombre de bucket o prefijo difiera de la configuración propia de prepare (un campo que no informa se lee en su valor por defecto). Una vez que la fila del directorio contiene una huella, una nueva ejecución escribe current y next a partir de ella, como hace loom cell restore, y rechaza solo mientras la huella de un proceso vivo no coincida con ninguna. En ambos casos la celda sigue lista durante el despliegue de LOOM_CELL. Un cambio de configuración posterior, mientras la celda está en attaching o serving, pasa por loom cell update; antes de que attach haya escrito la huella de la celda en la fila del directorio, escribe next solo en loom.cell_self, sin reservar nada (y --finish y --revert tocan entonces solo loom.cell_self), y un attach reanudado ejecuta sus rechazos por solapamiento sobre ambos valores de loom.cell_self, y los escribe en el directorio. Los emisores y patrones de orgs de una celda preparada no se reservan en ningún lugar: el router no le dirige ningún emisor ni toma ninguna ubicación de ella hasta que attach haya ejecutado sus rechazos por solapamiento y escrito su fila del directorio.

Un cambio en lo que acepta una celda pasa por loom cell update --config <file>, bajo el mismo bloqueo de directorio que attach; calcula next a partir de esa configuración con la misma función que usan los procesos, y se niega mientras haya un next distinto pendiente; volver a ejecutarlo con la misma configuración, o --finish, escribe primero next donde falte. Vuelve a ejecutar los rechazos por solapamiento de attach contra la fila del directorio de cada otra celda, contando ambos valores de cada una, escribe la nueva huella como next en el directorio y luego en loom.cell_self, de modo que los procesos antiguos y nuevos sirven a la vez mientras se despliega la nueva configuración. loom cell update --finish espera, como máximo --wait (por defecto 10 minutos), hasta que todos los procesos vivos informen next y haya pasado el plazo de solicitud más largo; cuando el cambio activa SCIM o cambia el cliente OIDC de la celda, ejecuta entonces la precondición de SCIM de attach (se niega, o aplica --revoke-unprovisioned); solo entonces convierte next en el único valor, primero en loom.cell_self y por último en el directorio. Un emisor o patrón ampliado se reserva en el directorio antes de que cualquier proceso lo acepte, y uno reducido se libera solo después de que ninguno lo acepte. Un rechazo o una espera que se agota conserva ambos valores e imprime los procesos que aún no informan next; volver a ejecutar reanuda, y loom cell update --revert espera del mismo modo hasta que ningún proceso vivo coincida solo con next (rechazando cuando --wait se agota), y luego descarta next, primero en loom.cell_self, bajo el mismo bloqueo; una org configurada que la actualización ubicó permanece ubicada en la celda (una ubicación nunca se elimina).

Un nuevo token de SCIM no cambia ninguna huella y no necesita loom cell update. Una celda cambia su aplicación del proveedor de identidad igual que un despliegue único (SSO y SCIM), con los mismos límites; nada de eso es particular de las celdas.

Las claves del heartbeat

El heartbeat de celda de un proceso informa, junto con el LOOM_CELL con el que se ejecuta, de su modo de tenencia: el estado que produce su última lectura de las filas de estado (open, recording, enforced o partial, y el recording de una celda posterior se lee como enforced), y '' solo antes de que llegue una lectura o en un proceso que nunca las lee. Su JSON fingerprint contiene la versión y los campos de la huella, y junto a ellos claves que ninguna huella compara: nunca están en loom.cell_self, en las huellas del directorio ni en el cuerpo de una ubicación, y una fila KeeperMap no necesita columna para ellas (server.core.instances.cell_row). Su presencia demuestra la compilación que las informa; no hay clave de generación.

  • serves: LOOM_SERVES_TRAFFIC.
  • marked: si las sesiones de Postgres agrupadas de este proceso conservan el marcador de tenencia (loom.tenancy_checked). El refresco de la celda lo lee junto con las filas de estado, después de RESET ALL en la misma transacción: un valor de arranque sobrevive al reset, un SET no, de modo que un pooler, que una celda no debe tener (Postgres), se lee como no marcado tanto si elimina los parámetros de arranque como si los envía de nuevo con SET, y la lectura se ejecuta en la conexión al servidor en la que se ejecutó el reset. Cuesta tres viajes de ida y vuelta más por refresco (BEGIN, RESET ALL y COMMIT), y todo proceso informa un valor reciente sin necesidad de sondeo. Una sesión que el pooler despojó, o un proceso con LOOM_CELL sin definir bajo la autoridad de Postgres, se lee como false; null significa solo que no ha llegado ninguna lectura (un arranque con migraciones de Postgres omitidas cuya primera lectura falló, o la autoridad de ClickHouse, donde no se lee nada). La comprobación de preparación cell_marker de un proceso con LOOM_CELL definido lee el mismo valor: falla en enforced y partial, donde los triggers rechazan las escrituras de una sesión sin marcar para una org que la celda no tiene y la fila de tenencia de cada org recién ubicada, y pasa con una advertencia en recording, de modo que una primera celda detrás de un pooler así no detiene su despliegue antes de attach, que rechaza el proceso (solución de problemas).
  • router y router_why: con LOOM_CELL definido, router es null y router_why indica por qué hasta que se lee la fila first, y después ambos están presentes solo en una primera celda (la ruta de estado de una celda posterior responde 404, así que ni pregunta ni los informa). router indica si la última lectura de este proceso de GET /cells/v1/cells/<cell> con su propia credencial respondió 200 nombrando la celda: null hasta que responde la primera lectura (aún arrancando), true ante tal respuesta, y false para una configuración que nunca funciona: un ajuste del router sin definir (el proceso nunca pregunta), una URL que no se puede solicitar, un 404, una respuesta para otra celda, o un 401 que persiste más allá de un LOOM_ROUTER_DIRECTORY_CACHE_S. Ese es el ajuste del router, que los procesos de la celda también llevan: los hashes de credenciales en caché de una réplica del router responden 401 para un token rotado hace un momento, así que hasta entonces se mantiene el último valor y router_why dice "401, possibly a rotation" (un router ejecutado con una caché más larga puede hacer que attach se rechace durante una rotación; volver a ejecutar lo resuelve). Un fallo transitorio (un timeout, un error de conexión, un 503, un 200 que no es un objeto JSON que nombre la celda) conserva el último valor, y mientras router es null, router_why nombra la última causa de ese tipo.

Un lector en segundo plano por proceso de servidor consulta la ruta cada min(LOOM_INSTANCE_HEARTBEAT_SECONDS, LOOM_TENANCY_MODE_CACHE_S) en una primera celda hasta que ha leído serving (server/core/cell_router.py); nada lo espera, de modo que un router lento no retrasa ningún latido ni ninguna solicitud, y el latido informa lo último que leyó, con una antigüedad de a lo sumo un periodo más LOOM_CELL_ROUTER_TIMEOUT_S cuando un latido lo escribe. Cada proceso uvicorn ejecuta uno, así que mil pods de ocho workers preguntan hasta 1,600 veces por segundo. Cada réplica del router responde la ruta a partir de su propia lectura de la fila de la celda, hecha como máximo una vez por LOOM_ROUTER_DIRECTORY_CACHE_S, de modo que el directorio ve una lectura por réplica y ventana; una lectura fallida responde 503 durante su ventana, así que un directorio caído no se consulta más a menudo y sigue respondiendo 503. Un proceso sin heartbeat (una CLI, el proceso hijo de los workers) pregunta bajo demanda, como máximo una vez cada LOOM_TENANCY_MODE_CACHE_S.

El lector conserva también la última respuesta del directorio para la comprobación de tenencia, como una de cuatro: attaching, serving, otro estado, o desconocido mientras no haya llegado ninguna lectura, la última haya fallado, se haya respondido para ningún estado de esta celda (un 401, un 404 o una respuesta para otra celda), o llegue tarde (más antigua que el periodo con el que este proceso lee, el del lector en segundo plano o la ventana bajo demanda, más LOOM_CELL_ROUTER_TIMEOUT_S). Una vez que un proceso ha leído serving lo conserva durante toda su vida y no pregunta más: solo loom cell restore lo rebaja, y eso reinicia los procesos. Una primera celda en recording registra una nueva org solo en attaching. Un principal de plataforma o de org *, o una llamada sin principal, no ubica ninguna org: en una primera celda cuyo directorio responde attaching, o no puede leerse antes de que haya leído serving, tal llamada para una org que la celda no tiene responde 503 ("attach in progress" o directorio ilegible), ya que los datos de la org pueden estar en esta celda hasta que attach la ubique; una vez serving, y en una celda posterior, responde 409 WRONG_CELL. Un proceso que arranca después de serving mientras el router está caído responde esas llamadas con 503 hasta que llegue su primera lectura.

Con LOOM_CELL definido, un LOOM_CELL_ROUTER_URL no vacío que no sea una URL http(s) con host, con un puerto de como máximo 65535 y sin ? ni # rechaza el arranque (cell.settings_problem); uno vacío está permitido, para pods solo de workers (LOOM_SERVES_TRAFFIC=false), cuyo heartbeat informa entonces router como false con los ajustes sin definir en router_why, sin registrar nada en el log.

La verificación de tenencia y la ubicación

Un proceso con LOOM_CELL sin definir no ejecuta ninguna verificación de tenencia. Bajo la autoridad de Postgres (LOOM_STORAGE_AUTHORITY=postgres, la única que ejecuta una celda) un proceso servidor sigue leyendo, en una sola sentencia, la fila de modo, la fila first y si existe alguna fila de loom.tenancy o loom.cell_self, con las reglas de la caché de modo (más abajo). Un comando de la CLI que declara una organización lee lo mismo en una sesión acotada propia: si todas las tablas de estado están ausentes (según to_regclass, de modo que un rol al que le falta un permiso sigue siendo rechazado) se lee como open, y una lectura fallida se rechaza. Un comando sin organización, como la revocación de un token, loom migrate o loom doctor, no está condicionado por el modo y se ejecuta, incluso con Postgres caído. Si ambas filas están ausentes y no hay fila de tenencia ni propia, como en un despliegue nunca preparado, o en la primera celda en recording, el proceso sigue sirviendo como un despliegue único; todo estado que la regla de la fila first (más arriba) cuenta como enforced, o como estado partial, lo condiciona igual que enforced. enforced (que attach establece en la primera celda cuando todos los procesos activos tienen LOOM_CELL definido, y prepare en una celda posterior, cuyos procesos lo ejecutan así desde su primer arranque) hace que un proceso servidor no esté listo, no ejecute ningún worker y no responda nada salvo sus sondas de salud y la ruta de sondeo (para que una nueva ejecución de prepare pueda alcanzarlo), y hace que el comando de la CLI se rechace; el motivo de disponibilidad y el rechazo nombran LOOM_CELL. Así, un pod o una CLI de operador que pierde LOOM_CELL en una celda enforced no escribe para ninguna organización; uno que además pierde LOOM_PG_DSN o LOOM_STORAGE_AUTHORITY es rechazado por la verificación de autoridad que el despliegue ya ejecuta (el registro loom.storage_authority de ClickHouse). Los comandos loom cell que se conectan a los almacenes de una celda (prepare, attach, place, restore, update) se rechazan sin LOOM_CELL y, una vez que el directorio tiene una fila para LOOM_CELL, rechazan los almacenes cuyo id de despliegue no sea el que esa fila registra. Un despliegue iniciado con LOOM_CELL sin definir es un despliegue único hasta que se prepara, y apuntarlo al prefijo de bucket de otro despliegue es la configuración errónea que es para cualquier despliegue. En la primera celda, loom cell prepare se ejecuta antes de desplegar LOOM_CELL; una celda posterior se ejecuta con LOOM_CELL definido desde su primer arranque, así que sus procesos están condicionados y se mantienen al margen de los workers (incluido su barrido de blobs) hasta que prepare escribe su fila, y prepare rechaza una celda posterior mientras el heartbeat de algún proceso activo carezca de LOOM_CELL o nombre otra celda. Prepare hace tres cosas, en orden:

  1. Rechaza una celda cuyos almacenes ya llevan la identidad de otra celda: un id de despliegue que el directorio registra, o un estado que el directorio no ha ubicado allí. El router lo comprueba, en la propia transacción del registro, a partir de los recuentos que envía prepare: una celda para la que el directorio no tiene fila no puede contener filas de tenencia, first, de modo ni propia, y una posterior no puede tener ningún objeto bajo su prefijo salvo la sonda de prepare ni ningún proceso activo sin su LOOM_CELL. Una nueva ejecución cuenta como propios las filas de tenencia y de estado y los objetos del prefijo; los procesos de una celda posterior se ejecutan con su LOOM_CELL en cada ejecución, lo que prepare comprueba por sí mismo.
  2. Registra la celda en el directorio como attaching, bajo el bloqueo del directorio: su host, el id de despliegue leído de la celda, el SHA-256 de la credencial con la que llama al router, y el nombre y el prefijo de su bucket, comparados con los de cualquier otra celda, preparada o adjuntada. La credencial es lcr_ seguido de 128 caracteres hexadecimales en minúscula (512 bits), tal como la genera loom cell credential new sin conexión, imprimiendo la credencial y su hash; el arranque y loom doctor rechazan un LOOM_CELL_ROUTER_TOKEN de cualquier otra forma. Prepare recibe el hash como argumento, 64 caracteres hexadecimales en minúscula, de modo que ninguna CLI necesita el secreto; cualquier otro valor, incluidas la credencial o su secreto de 128 caracteres, se rechaza, nombrando loom cell credential new, y no se almacena en ningún sitio. Ninguna otra fila de celda puede contener el hash, ni como actual ni como siguiente.
  3. Escribe las filas de la celda: el modo (recording en la primera celda, enforced en una posterior), la fila first y current.

Prepare es reanudable. Una nueva ejecución para la fila del directorio con el mismo nombre, id de despliegue y host escribe la que falte entre la fila first y la fila de modo, a partir del estado del directorio, y loom.cell_self como se indicó (antes de attach, a partir de los heartbeats cuando falta; una vez que el directorio guarda la huella, current y next a partir de ella, sobrescribiendo un valor presente que difiera); antes de attach, una fila propia presente se mantiene, y un proceso activo que no ejecute ni su current ni su next se rechaza. El estado del directorio es el valor first que nombra el índice único y el modo más alto que registra para la celda: recording para la primera celda o enforced para una posterior en el registro, en la misma transacción que la fila, y luego cada modo que attach eleva, registrado en el directorio antes de que attach lo establezca en la fila de modo de la celda (un rechazo informa de la fila de modo tal como attach la lee de vuelta tras cualquier retorno a recording, y nunca baja el registro del directorio). Una nueva ejecución rechaza una fila de modo por encima del estado del directorio y la fila recording de una celda posterior, al no ser ninguna de la celda en cuestión, y deja la fila de una primera celda por debajo de él para que attach la termine. Una nueva ejecución rechaza un hash de credencial que no sea ni el current ni el next de la fila (la rotación corresponde a loom cell credential), cuenta como propias las filas de tenencia ubicadas o registradas desde su propio registro, y omite las comprobaciones del registro que ya ha superado (el prefijo vacío y el solapamiento de prefijos), de modo que se ejecuta en una celda serving cuyo prefijo contiene datos.

Un proceso con LOOM_CELL definido y sin fila de modo no pasa a estar listo. Con él definido, el Postgres de cada celda contiene loom.tenancy (org, since) y loom.tenancy_mode (recording, enforced); un proceso lee el modo a través de una caché de como máximo LOOM_TENANCY_MODE_CACHE_S (por defecto 5 s), conserva el último modo leído cuando no puede leerlo, y sigue sirviendo las organizaciones que posee, durante como máximo LOOM_JWT_REVOCATION_MAX_STALE_SECONDS, pasado lo cual queda condicionado hasta que una lectura se complete. Todo proceso servidor bajo la autoridad de Postgres, con LOOM_CELL definido o no, lee las filas justo después de que sus almacenes se abran y migren, antes de su primer heartbeat y de su decisión de arrendamiento; una primera lectura fallida hace fallar su arranque (con migraciones de Postgres pendientes arranca condicionado y no listo hasta que una lectura se complete). Después, un proceso con LOOM_CELL definido mantiene el límite de obsolescencia anterior, y uno con él sin definir mantiene su veredicto a través de lecturas fallidas sin límite de obsolescencia, igual que un despliegue único supera una caída de Postgres (la primera excepción en Invariantes). El proceso hijo de workers de una celda lee sus propias filas y queda condicionado hasta que una lectura se complete. Con LOOM_CELL sin definir, la ausencia de filas de modo y first sin fila de tenencia ni propia es un despliegue nunca preparado, y una lectura fallida nunca se toma por una fila ausente; un proceso que no lee estado (el hijo de workers y una CLI con LOOM_CELL sin definir, y todo proceso bajo la autoridad de ClickHouse) no está condicionado por ello. En enforced, una celda sirve exactamente las organizaciones para las que tiene una fila; una organización que un proceso leyó como no poseída, para un llamante que actúa en otra organización, se vuelve a leer tras LOOM_TENANCY_MODE_CACHE_S. Una fila recording se escribe con una sentencia que la inserta solo mientras el modo es recording, leyendo la fila de modo con FOR SHARE; se ejecuta en READ COMMITTED en su propia transacción y se confirma antes de que la solicitud continúe. La escritura de enforced por parte de attach y estas inserciones nunca se cruzan: una inserción que ya se ejecuta cuando attach escribe el modo la ubica el paso 4, una que empieza después lee enforced, un flujo de inserciones no puede retener la escritura, una solicitud de nueva organización espera a attach unos pocos segundos como máximo, y un attach que se atasca reteniendo el bloqueo de la escritura lo libera en cuestión de segundos. Attach toma LOCK TABLE loom.tenancy_mode IN EXCLUSIVE MODE (que espera a las inserciones en curso y pone en cola a las posteriores detrás de él) en intentos cortos, en una transacción con tiempos de espera del lado del servidor, luego escribe el modo y confirma; tras cualquier error en esa transacción termina el backend de esa sesión (pg_terminate_backend, el backend nombrado por el pid y el backend_start que attach capturó al conectarse) y espera hasta que haya salido de pg_stat_activity, luego lee el modo de vuelta antes de reintentar o informar; un modo leído de vuelta como enforced se escribe de nuevo en una transacción nueva, cuya confirmación espera al standby, antes de que attach continúe, ya que una confirmación terminada mientras esperaba está solo en el primario. El comando attach fija esos tiempos de espera, y sus pruebas cubren cada uno de estos casos. La caché de modo lee el modo con un SELECT simple, que no toma ningún bloqueo de fila y nunca espera a attach. Una inserción que encuentra enforced (un proceso cuya caché aún lee recording) no escribe nada: la solicitud pasa a la llamada de ubicación como en enforced, y un comando de la CLI se rechaza como en enforced, nombrando la organización. Un proceso cuya caché aún lee enforced después de que el paso 3 o el paso 4 devuelva la celda a recording ubica a través de la puerta del router hasta que su caché expire. loom doctor lista cualquier fila de tenencia que el directorio no ubique.

  • Se ejecuta después de la verificación y antes de escribir nada para la organización. La puerta de operaciones (gates.authorize) comprueba primero la organización que resuelve el transporte (gates.resolve_org, con sus valores por defecto del llamante y las organizaciones de plano), antes de check_acted_for y del aprovisionamiento del espacio de nombres personal, tanto para HTTP como para MCP (por MCP una llamada para la organización de otra celda responde isError, de modo que un lote conserva sus otras respuestas, y una llamada en la propia organización del token, tal como la resuelve gates.resolve_org, se comprueba antes de leer los valores por defecto del llamante, ya que viven en esa organización). Las rutas fuera del registro comprueban mediante check_authorized, admit_org o la propia comprobación, y un middleware comprueba la propia organización del bearer verificado en las que actúan en ella (las rutas que el censo marca token; para un token de toda la organización o sin organización en las rutas del llamante que recurren a ella, la organización de registro, comprobada sin principal, de modo que se registra o se rechaza, nunca se ubica). Un principal que no puede actuar en la organización (un token de otra organización) es rechazado primero, con el 403 de la puerta, de modo que no registra, no ubica y no aprende nada: ni si la celda posee la organización, ni dónde está ubicada. Una operación cuyo campo de organización se llama de otro modo (from_org) llega a la misma comprobación mediante check_authorized, y una prueba de censo lista cada uno de esos campos. Un rechazo escrito antes de la comprobación (JSON mal formado, un argumento desconocido, un fallo de validación) no nombra en su telemetría ni en su traza de código ninguna organización que la celda no posea. Una prueba unitaria lista todas las rutas de la aplicación y falla a menos que estén marcadas como con tenencia comprobada o sin organización.
  • La CLI declara sus organizaciones. Todo comando de la CLI que se conecta pasa por run_connected, connect_checked o connect_declared (server/cli/_ch.py), que reciben las organizaciones en las que escribe el comando, o por qué no escribe para ninguna. Un comando que declara una organización comprueba primero su despliegue (check_configured), de modo que bajo la autoridad de Postgres necesita LOOM_PG_DSN. En una celda, antes de comprobar una organización declarada, leen las filas de la celda y rechazan el comando a menos que la fila first nombre su celda y sus almacenes (deployment_id, bucket, bucket_prefix) coincidan con un valor de la fila propia de la celda: una CLI no verifica ningún token y su huella nunca llega al router, así que puede ejecutarse donde los transportes rechazan por otro campo de la huella. Con LOOM_CELL sin definir, el comando se rechaza en una celda más allá de recording (más arriba). Una organización que la celda no posee se registra en la primera celda en recording, igual que la organización de una solicitud (leyendo el estado de la celda con la credencial de router de la celda, LOOM_CELL_ROUTER_TOKEN, en la configuración de la CLI de la primera celda mientras su modo es recording, y solo mientras el directorio responda attaching), y se rechaza en enforced; nunca se ubica. Un comando del índice de código declara la organización en la que escribe: su --org, o si no LOOM_CODE_ORG. Una pasada sobre todos los repositorios configurados no declara ninguna, ya que attach, o el loom cell update que cambia uno, ubica las organizaciones configuradas, y un comando de solo lectura o una ejecución en seco no declara ninguna, ya que una lectura no registra nada. Un comando sin organización dice qué hace con los almacenes: lee, escribe (loom ch-setup, secrets, un cambio de ajustes, prepare y el resto; una ejecución en seco lee) o revoca (loom revoke-token, la revocación de un usuario SQL, loom signing-key retire, loom bot disable, loom sso unlink; uno que pueda devolver el acceso es una escritura), por subcomando cuando una conexión sirve a varios (loom signing-key: list lee, retire revoca, rotate y record-root escriben). Con LOOM_CELL definido, una escritura o una revocación comprueba su ClickHouse contra su Postgres (check_configured), lee la fila first en una sesión acotada propia y rechaza cuando nombra otra celda, lo que siempre ocurre con una CLI apuntada a los almacenes de otra celda, o cuando la lectura falla; una fila ausente, o tablas de estado aún sin migrar, pasa, de modo que una celda posterior ejecuta esto antes de estar preparada. Una revocación se ejecuta durante una caída (la cuarta excepción en Invariantes); una escritura se rechaza durante una; una lectura no está condicionada. loom ch-setup, que configura ClickHouse con un cliente propio, ejecuta la misma puerta antes de escribir, y un ClickHouse sin registro todavía pasa; loom migrate y loom provider-lock clear escriben a través del cliente propio del ejecutor de esquemas y no están condicionados. Una prueba de censo falla ante una conexión que no declara ninguna de las dos cosas, ante una sin organización que no diga de qué tipo es, ante una conexión bajo server/cli/ fuera de _ch.py, y ante un comando loom code que resuelve su organización sin conectarse para ello. Un titular de la credencial de router de la celda puede ubicar organizaciones para la celda, dentro de la tasa de la celda y de placements_max, igual que la credencial de operador que usa loom cell place puede hacerlo para cualquier celda dentro de su placements_max (una llamada de operador no tiene límite de tasa ni cuenta para la tasa de la celda), y una ubicación es permanente, de modo que un nombre de organización que toma se pierde para todas las demás celdas: un poder sobre el directorio compartido del que carecen las credenciales de almacén de la celda. Por eso los pods la tienen, y una CLI solo para la única lectura que la necesita, mientras el modo de la primera celda es recording: un comando de la CLI que declara una organización se niega a ejecutarse con ella definida, nombrándola, a menos que la celda sea la primera y su modo lea recording, y un comando sin organización nunca la usa; una filtrada se detiene con loom cell limit --closed, que no necesita ninguno de los almacenes de la celda, y se reemplaza con loom cell credential (más abajo). loom cell place --org <org> (declarado sin organización: escribe la ubicación de la organización y la fila de tenencia, que es como una organización pasa a ser poseída), con la credencial de operador del router, ubica una organización para un comando que escribe una nueva (un bot, una importación), a través de la API de ubicación del router y en su orden, igual que la ubicación de organizaciones configuradas por attach: inserta la ubicación y lee de vuelta la ganadora, escribe la fila de tenencia de la celda solo si la ganadora es esta celda (de lo contrario se rechaza y no escribe nada), e informa del éxito solo una vez que la fila está escrita, de modo que una nueva ejecución es idempotente. Para una organización que el directorio aún no ubica pasa la puerta de la API de ubicación (más abajo): se rechaza mientras el directorio no está disponible, para una celda que la puerta no acepta, cerrada, o cuando la huella de la propia configuración de la CLI de la celda (con el id de despliegue leído de los almacenes a los que se conecta) no coincide con ningún valor de la fila de la celda, o más allá de placements_max, y cuenta para él.
  • Los escritores anteriores a la verificación son rechazados por los almacenes en los que escriben. Una sesión que ejecutó la verificación de tenencia se marca con loom.tenancy_checked = 'on': toda sesión de un proceso con LOOM_CELL definido lo envía como parámetro de inicio (de modo que el RESET ALL del pool lo conserva), y la sesión de migración lo establece tras tomar el bloqueo de migración, ya que los pasos de datos de una migración solo copian o reescriben filas ya almacenadas. En cada tabla ordinaria de la autoridad con una columna org (no la propia loom.tenancy, ni loom.idempotency ni loom.idempotency_fences, con clave en la organización del token del llamante) un trigger a nivel de fila AFTER INSERT y AFTER UPDATE, habilitado como trigger de origen, omite una sesión marcada en su WHEN (el de update también omite una actualización que deja intacta la organización de la fila, de modo que un ON CONFLICT DO UPDATE que alcanza una fila existente no se rechaza) y llama a una función (migración 011). La función sigue la regla de estado (más arriba): deja pasar todas las filas mientras el estado es open o una primera celda está en recording, y en todos los demás estados rechaza, con SQLSTATE LT001 (503 TENANCY_REFUSED para un llamante), una fila de una organización sin fila de tenencia (nunca '', '-' ni '*'); lee el estado una vez que la fila está escrita, sin bloqueo de fila, de modo que ninguna escritura queda en cola detrás de attach, y el paso 4 (más abajo) espera a que termine toda transacción que pudiera haber leído recording. Un arranque con migraciones activadas crea los triggers, en cada tabla de ese tipo que encuentra en el catálogo, solo en una celda totalmente preparada en enforced, y, allí, restablece a origen cualquiera que encuentre no en origen; el DDL de cada tabla espera 100 ms por intento su bloqueo, tres intentos separados un segundo (unos 2.3 s para una tabla ocupada, de modo que un arranque que encuentra ocupadas todas las tablas protegidas espera ese tiempo en cada una por turno, reteniendo el bloqueo de migración que esperan otros pods en arranque), y el arranque sigue sirviendo más allá de una tabla cuyo bloqueo no puede tomar, registrado con los titulares de sus bloqueos, o una que el rol no puede alterar, registrado como tal (la tercera excepción en Invariantes). Una primera celda está en recording hasta que attach establece enforced mientras se ejecuta, de modo que ningún arranque puede haberlos creado: attach los crea él mismo con la misma pasada (cell_triggers.ensure) una vez que ha establecido enforced, y la celda pasa a serving solo cuando cell_triggers.missing no nombra ningún defecto. Una celda posterior está en enforced desde prepare y los obtiene en su primer arranque con migraciones tras prepare, lo que su attach exige del mismo modo. loom doctor nombra uno deshabilitado o alterado en cualquier estado, uno ausente en una celda enforced, y una tabla particionada con una columna org como no admitida, ya que no recibe trigger. Los triggers de origen no se disparan en la aplicación de la replicación lógica ni con session_replication_role = replica, que los scripts de una celda no usan. La marca no es una frontera de privilegios: un escritor que la establece a propósito pasa; los triggers detienen a los escritores que no la conocen, una CLI más antigua, un pod degradado más allá de la verificación, o un script, para que no añadan una fila de una organización que la celda no posee ni muevan una fila a una; una actualización que conserva la organización de una fila, y un borrado, no se rechazan. El coste de los triggers de organización es una consulta de ajuste por fila marcada, y una lectura del estado y una consulta de loom.tenancy por fila no marcada; la puerta con la que se publican es un aumento del p99 de memory.set de como máximo 10 ms y una tasa de filas por segundo de una pasada de entrega a LOOM_PG_DELIVERY_BATCH_ROWS como máximo un 10% menor, en enforced con las organizaciones poseídas. Toda escritura de Loom en una celda está marcada, así que paga solo la consulta de ajuste, medida sobre las sentencias con los triggers activados y desactivados (ningún coste distinguible de cero: seis rondas van de −0.36 a 0.49 µs por fila, resultados de benchmark), lo que predice que la puerta se cumple con un amplio margen. La puerta en sí es una medición de extremo a extremo de memory.set y de una pasada de entrega en una celda, que necesita attach y se comprueba con él; hasta entonces los triggers, que una celda posterior obtiene del siguiente arranque con migraciones de prepare, se publican con la medición a nivel de sentencia. loom.tenancy tiene su propia protección, ya que una fila de tenencia hace que una organización sea poseída: tenancy_record, un trigger de origen a nivel de fila AFTER INSERT OR UPDATE OF org con el mismo WHEN de marca, llama a loom.tenancy_refuse_unmarked() (migración 012), que rechaza, LT001, la fila de tenencia de una sesión no marcada, o una actualización que la mueve a otra organización, en todos los estados salvo una primera celda aún en recording (también open, ya que la propia fila haría que el estado fuera partial), de modo que un script no puede hacer poseída una organización que el directorio no ubica. Los arranques y attach lo crean y lo reparan como a los triggers de organización. Con attach, loom doctor lista también cualquier fila de tenencia que el directorio no ubique, lo que nombra una escrita antes de la protección o por un escritor que estableció la marca, y cualquier organización en una tabla de Postgres con clave de organización sin fila de tenencia, lo que nombra filas escritas antes de los triggers de organización, por un escritor que estableció la marca, o dejadas por una fila de tenencia borrada. Antes del primer attach, el operador rota las credenciales de escritor de ClickHouse de la celda (crea el nuevo usuario, lo despliega en las configuraciones de las compilaciones que comprueban, elimina el antiguo), y attach se rechaza mientras algún usuario de ClickHouse con INSERT sobre loom.* (system.grants, siguiendo los permisos de base de datos, globales y de rol a través de system.role_grants, y contando los usuarios de archivos de configuración o con ALL implícito) no sea uno que informe un proceso activo de una compilación que comprueba o el usuario configurado de la CLI, de modo que solo los titulares de la credencial rotada escriban en ClickHouse; una CLI más antigua a la que se dé esa credencial sigue escribiendo sin comprobar, y con attach loom doctor lista lo que escribió: cualquier organización hallada en una tabla de ClickHouse con clave de organización sin fila de tenencia, a partir de la misma lista de esquemas que el paso 2 de attach.
  • Una organización que la celda no posee se ubica allí o se rechaza. Para un principal verificado con alcance a la organización (un token de esa organización, o un principal de un emisor o bot cuya organización es esa), la celda llama a la API de ubicación del router (POST /cells/v1/placements en LOOM_CELL_ROUTER_URL, respondida con la celda ganadora y su id de despliegue) con su propia credencial (LOOM_CELL_ROUTER_TOKEN), y la celda que nombra la llamada debe ser aquella cuyo hash registrado coincide con la credencial (un hash nombra una celda): el router ubica una organización a la vez (un bloqueo con alcance de transacción sobre la organización, que toda ruta que ubica toma), responde con su celda a una organización ya ubicada, y en otro caso juzga a la celda solicitante según su fila bloqueada, inserta la ubicación y lee de vuelta la ganadora, que la celda compara por su nombre y su id de despliegue registrado. Si la ganadora es esta celda, la celda escribe la fila de tenencia y sirve la solicitud; el nombre de esta celda bajo otro id de despliegue que el que verificó el proceso responde 503 y no escribe nada; si es el nombre de otra celda, la solicitud responde 409 WRONG_CELL y no se escribe nada. Esta es la única vía por la que una solicitud lleva una organización a una celda, sea cual sea lo que la creó: una emisión, el token de una pasarela o de un emisor federado, una organización prefix* de un emisor de usuarios finales, un bot. Un principal de organización * o de plataforma actúa solo en organizaciones que la celda ya posee y nunca ubica una (en una primera celda antes de serving, véase las claves del heartbeat). Para una organización que el directorio aún no ubica, el router acepta una llamada de ubicación solo de una celda serving (o de la primera celda mientras está en attaching una vez que el directorio registra enforced, que el paso 3 de attach escribe antes de que establezca el modo de la celda), y solo con la huella de configuración del proceso que llama, cuyos campos deben coincidir con un valor de la fila de directorio de la celda; la fila de una celda preparada no contiene emisores ni patrones de organización hasta que attach los escribe. Una llamada fallida, una sin respuesta dentro de LOOM_CELL_ROUTER_TIMEOUT_S, una celda aún no adjuntada o cerrada a nuevas organizaciones, o una huella que no coincide con ningún valor responde 503 y no escribe nada; un reintento es seguro, ya que la lectura de vuelta lo hace idempotente. Para una organización que el directorio ya ubica, la llamada de una celda se comprueba solo por su credencial (contra los hashes de las celdas que el router guarda en caché durante LOOM_ROUTER_DIRECTORY_CACHE_S, por defecto 5 s) y por la tasa de la celda, y un loom cell place solo por la credencial de operador; ambos responden con la ganadora sea cual sea el estado, la cuota o la huella de la celda, sin añadir ubicación (la ganadora es pública de todos modos mediante la consulta); una solicitud rechazada por superar la tasa de su celda responde 503 con Retry-After (como máximo un minuto), y su reintento lo admite la réplica que la responde una vez que las llamadas de la celda allí están por debajo de la tasa. Una organización que la celda ya posee no necesita llamada, de modo que servirla nunca depende del router.
  • Las ubicaciones están acotadas por celda. Cada réplica del router limita la tasa de las llamadas de ubicación de cada celda por minuto (LOOM_ROUTER_PLACEMENTS_PER_MINUTE), lo que acota su ritmo a esa tasa multiplicada por las réplicas, y la fila de directorio de una celda puede llevar una cuota de ubicaciones (placements_max, sin definir por defecto), que una vez definida acota su total, contado e insertado bajo un bloqueo sobre la fila de directorio de la celda, de modo que las llamadas concurrentes entre réplicas del router nunca la superan; superada la tasa, toda llamada de ubicación de la celda responde 503 con Retry-After; superada la cuota, una llamada para una organización que el directorio aún no ubica responde 503 como para una celda cerrada (un loom cell place de operador está exento de la tasa, como se indicó); y las ubicaciones de cada celda se informan en /v1/health?include=capacity y por loom doctor, que nombra una celda sin cuota. Toda organización que ubica el attach de la primera celda (la instantánea del paso 2, incluidas sus organizaciones configuradas, y las del paso 4) se cuenta pero nunca se rechaza por cuota ni por celda cerrada, ya que la celda ya la sirve y rechazarla dejaría sus datos varados (una que supere ORG_MAX_BYTES la rechaza el directorio, más abajo); toda otra ubicación de una organización que el directorio aún no ubica, incluidas las organizaciones configuradas de una celda posterior en attach y una modificada en loom cell update, pasa la puerta, incluidas una celda cerrada y placements_max, de modo que una celda posterior cerrada o llena antes de attach rechaza el attach, nombrando la organización.
  • La primera celda registra hasta enforced como lo hace un despliegue único. En recording, que dura hasta que el paso 3 escribe enforced en el modo de la celda (y de nuevo siempre que el paso 3 o el paso 4 la devuelve a ese modo), una solicitud verificada para una nueva organización escribe una fila de tenencia sin llamada de ubicación, de modo que la tasa del router, placements_max y loom cell limit --closed no se aplican: las nuevas organizaciones llegan como en un despliegue único, acotadas por sus propios ajustes de registro, emisor y JIT, y el paso 2 o el paso 4 las ubica sin rechazo. loom doctor lista las organizaciones registradas que no contienen datos, para que el operador vea lo que attach ubicará.
  • Las organizaciones configuradas se ubican en attach. El oidc_jit_org de la celda, el self_signup_org de una celda con registro activado, y sus organizaciones de código (LOOM_CODE_ORG y la organización de cada entrada de LOOM_CODE_REPOS_JSON que conserva la configuración de código) y la organización del tracker se ubican como propias cuando se adjunta: las de la primera celda en la instantánea del paso 2, las de una celda posterior antes de marcarla serving. JIT y el registro propio pasan la verificación de tenencia como cualquier solicitud, y nada se rechaza en el arranque: en recording de la primera celda registran su organización mientras el directorio responde attaching, y en otro caso una organización configurada que la celda no posee responde 503 hasta que se ubica (422 para una que supere ORG_MAX_BYTES, que el directorio rechaza), lo que loom doctor nombra; todo attach, primero o posterior, nuevo o reanudado, ejecuta los rechazos por solapamiento y ubica las organizaciones configuradas de ambos valores de loom.cell_self, de modo que una que una actualización puso en next antes de attach se ubica con las demás; una vez que attach ha escrito la fila de directorio de la celda, loom cell update ubica una modificada en la transacción de directorio que escribe next, a través de la puerta de la API de ubicación para una organización que el directorio aún no ubica (incluidas las celdas cerradas y placements_max), rechazando, nombrándola, cuando otra celda la posee, y luego escribe su fila de tenencia en la celda; para una celda posterior aún attaching tras su transacción de directorio, loom cell update rechaza un cambio de organización configurada hasta que la celda está serving. En enforced, un worker escribe para una organización solo una vez que la celda la posee (la verificación de tenencia sin principal), de modo que una celda posterior no indexa, importa ni barre nada bajo sus organizaciones configuradas antes de que attach las ubique; en recording, los workers se ejecutan como antes, y la instantánea del paso 2 y la segunda lectura del paso 4 encuentran todas las organizaciones en las que escriben.
  • Las filas nunca se borran. Una fila de tenencia y una ubicación nombran una organización, no su memoria: ambas se clasifican para el borrado como sin contenido de memoria, igual que la reclamación de un espacio de nombres, y permanecen tras cualquier borrado, de modo que un nombre de organización nunca queda libre para otra celda. Un proceso conserva las organizaciones que ha visto poseídas, y servir una conservada nunca es erróneo.
  • Un único límite de nombre de organización. Una celda no registra ni ubica ninguna organización nueva de más de ORG_MAX_BYTES (2048 bytes UTF-8, server/core/cell.py, por debajo del límite de entrada de índice de Postgres): la verificación de tenencia de una celda en recording rechaza una con 422 y no escribe nada, y el directorio rechaza una con 400 (ORG_TOO_LONG) antes de escribir una ubicación, para toda ruta que ubica, lo que la ubicación de una celda convierte en el mismo 422 (por MCP, un error de herramienta contado como del llamante). Así, toda organización que registra una celda puede ubicarse, y una organización poseída o ubicada antes del límite conserva su celda.
  • Una organización ubicada sin fila (una restauración a un momento anterior a su ubicación) recupera su fila con loom cell restore, antes de que la celda restaurada arranque (Qué ejecuta cada celda).

Adjuntar una celda

loom cell attach, ejecutado contra el router, registra una celda, un attach a la vez, y se niega ante cualquier fallo, nombrándolo:

  • la celda responde en su propio host con el id de despliegue que informa su probe_url, cada proceso activo tiene LOOM_CELL establecido con su nombre, ejecuta la autoridad de Postgres con un standby síncrono (LOOM_PG_DURABILITY=synchronous) y autenticación obligatoria, y registra un id de despliegue que ninguna otra celda registra;
  • en la primera celda, el rol de Postgres de attach puede leer el estado de transacción de cada backend (pg_read_all_stats) y el Postgres de la celda no permite transacciones preparadas (max_prepared_transactions = 0), de modo que el paso 4 ve todas las transacciones abiertas;
  • sus claves son propias: ningún emisor que acepta para tokens bearer es aceptado por otra celda, y la huella de su secreto raíz (keys_fp) no coincide con la de ninguna otra celda. Los proveedores de identidad upstream y los emisores de cargas de trabajo pueden compartirse, ya que una celda emite su propio token a partir de ellos; un gateway (LOOM_IDENTITY_PROVIDER=gateway) emite para una sola celda, por lo que un despliegue ejecuta un gateway por celda;
  • ningún proceso activo de otra celda informa una huella que no coincida con ninguno de los dos valores de su fila del directorio, y cada proceso activo de la celda que se adjunta coincide con su current o next de loom.cell_self (attach nombra cualquiera que no lo haga);
  • ninguna otra celda registra el mismo par (emisor OIDC, id de cliente) (la fila del directorio los registra, y loom cell update los cuenta en sus rechazos por solapamiento);
  • con SCIM activado, cada token SCIM que posee la nombra (lsc_<cell>_…) o, solo en la primera celda, no nombra a ninguna; una celda posterior no posee ninguna fila de usuario SCIM ni lápida (sus personas se aprovisionan después de attach, en el orden LOOM_CELL, un token con nombre y luego la asignación de la aplicación);
  • su LOOM_PUBLIC_BASE_URL está establecida (un proceso con LOOM_CELL establecido se niega a arrancar sin ella, de modo que ninguna URL que entrega proviene del Host de una solicitud), y los hosts de ella y de LOOM_OAUTH_ISSUER (si está vacío se resuelve a la URL base pública) son iguales a su host registrado: para la primera celda, cuyo host registrado es el host compartido, son el host compartido o un alias registrado de él; el host de ninguna celda posterior es el host compartido ni un alias, lo que impone la tabla hosts del directorio (host como clave primaria, normalizado por una sola función, normalise_host: minúsculas, IDNA a ASCII, sin punto final ni puerto por defecto, con los corchetes conservados en IPv6, usada por hosts, la regla 1, attach y la comprobación de preparación; propiedad de una celda, con un alias perteneciente a la primera celda), escrita en la misma transacción que cada comprobación, y a partir de la cual la regla 1 enruta; LOOM_JWT_ISSUER es una cadena opaca que solo necesita ser única; prepare comprueba lo mismo;
  • sus orgs configuradas no colisionan con ninguna org ubicada en otra celda, y ningún patrón de org en el que confía (los orgs de sus emisores de usuarios finales) se solapa con los patrones u orgs configuradas de otra celda, ni el patrón de otra celda coincide con sus orgs configuradas, según la regla de solapamiento que un despliegue único aplica a sus propios emisores de usuarios finales;
  • sus almacenes no son los de otra celda: una clave de sondeo escrita en un nombre reservado de su KeeperMap loom._migration_lock no es visible para ninguna otra celda y el sondeo de cada otra celda le es invisible (un ClickHouse sin Keeper se niega); su prefijo de bucket no es prefijo de ruta del de otra celda en un bucket del mismo nombre, en ningún endpoint, ni tiene uno, y los objetos de sondeo no se listan en ninguna dirección;
  • cada proceso activo de cada celda ejecuta una build cuya predecesora también ejecuta la comprobación de tenencia (abajo), y un heartbeat que informa su modo de tenencia, su huella y el LOOM_CELL con el que se ejecuta;
  • con SCIM activado, ninguna cuenta activa tiene un contacto o correo verificado sin una fila SCIM activa (incluidas cuentas con contraseña, sesiones de refresco vivas y cuentas de servicio personales), y ninguna cadena de creador de una cuenta de servicio viva termina en una cuenta sin correo (tokens de registro de agente creados antes de SSO): attach las lista y se niega, o con --revoke-unprovisioned finaliza sus tokens emitidos antes del attach bajo el propio prefijo de revocación de SCIM, de modo que una persona que el proveedor de identidad aprovisione después sea admitida, ya que nunca desaprovisionará a una persona que no cuenta como asignada.

El primer attach convierte el despliegue existente en la primera celda, en orden:

  1. comprobar que el modo es recording, como lo dejó prepare: cada solicitud verificada ha escrito la fila de tenencia de su org si faltaba mientras el directorio respondía que la celda estaba attaching;
  2. en una transacción del directorio, escribir attach_started_at, los emisores, patrones y huella de la celda (ambos valores de loom.cell_self), y las ubicaciones, luego las filas de tenencia, de cada org que la celda contiene, a partir de un snapshot, directamente en el directorio (todavía no existe otra celda): sus orgs configuradas (de ambos valores), el org distinto de cada tabla de ambos esquemas (generado a partir del esquema, como lo es la clasificación de tablas del borrado) y las orgs de los objetos de bucket catalogados; nunca '', '-' ni '*';
  3. establecer enforced como arriba, dentro de --wait, que la espera siguiente comparte, sin iniciar ningún intento que pudiera confirmar el modo con menos tiempo restante que el mínimo de esa espera (la vida de la caché del modo más el plazo de solicitud más largo): attach se niega entonces, informando el modo que lee de vuelta (recording, y una nueva ejecución reanuda desde el paso 1), o el modo como desconocido cuando no puede leerlo, y una nueva ejecución reanuda según el modo que lea; luego esperar, dentro de lo que quede de --wait (por defecto 10 minutos, después se niega y vuelve a establecer recording), hasta que cada proceso activo informe enforced y hayan pasado la vida de la caché del modo más el plazo de solicitud más largo; luego ejecutar de nuevo la precondición SCIM (otra vez --revoke-unprovisioned si se dio), para las cuentas creadas antes de que enforced surtiera efecto; si se niega, la celda permanece enforced y attaching, y ejecutar attach otra vez reanuda desde la espera, como hace un attach reanudado (abajo);
  4. esperar, dentro de lo que quede de --wait, hasta que no quede abierta ninguna transacción que pudiera haber leído recording, juzgado a partir de un snapshot de Postgres que attach toma una vez que ha leído enforced de vuelta en esta ejecución (no a partir de un reloj): cuenta como abierta una transacción en la base de datos de la celda que empezó antes de él, desde cualquier cliente, worker en segundo plano o conexión de replicación lógica, incluidas las de solo lectura; una transacción de escritura en otra base de datos del mismo servidor que lo hizo (retiene el horizonte de cada snapshot, y se nombra como tal); una transacción preparada (que se niega de inmediato); o una cuyo estado attach no puede leer; y no cuentan los procesos de mantenimiento propios de Postgres, las conexiones de replicación física (las de cada standby y de un base backup, que no ejecutan SQL) ni las conexiones propias de attach. Pasado --wait, attach se niega, nombrando lo que esperaba, y deja la celda enforced, de modo que una nueva ejecución reanuda desde la espera del paso 3. El comando attach fija la consulta exacta, y sus pruebas cubren cada tipo de transacción. Una vez superada la espera, ubicar las filas de tenencia escritas desde el snapshot y cada org que las fuentes del paso 2 producen al leerlas de nuevo (el org distinto de cada tabla de ambos esquemas y las orgs de los objetos de bucket catalogados; también se ubica una fila o un objeto que un escritor sin comprobación, como una CLI antigua o un worker, escribió en recording después del snapshot), comprobar de nuevo que cada proceso activo informa enforced (negándose y volviendo a recording como hace el paso 3 si alguno no lo hace), y marcar la celda como serving. El directorio registra el modo más alto que attach ha subido o intentado subir, que loom cell restore escribe de vuelta solo hacia arriba: una celda cuyo paso 3 fue rechazado en el bloqueo se restaura a enforced, y su attach reanudado se ejecuta entonces desde la espera del paso 3.

Una celda posterior se adjunta solo cuando la primera está serving. No debe contener datos de orgs (attach se niega en caso contrario) y comienza en enforced. Su attach ejecuta, en orden: los rechazos; una transacción del directorio, bajo el bloqueo del directorio y con los rechazos por solapamiento ejecutados de nuevo dentro de ella, que escribe attach_started_at, las ubicaciones de sus orgs configuradas y sus emisores, patrones y huella (ambos valores de loom.cell_self), negándose y sin escribir nada cuando una lectura de vuelta nombra a otra celda (nombra la org); las filas de tenencia de sus orgs configuradas y de su loom.cell_self, en la celda; la precondición SCIM (--revoke-unprovisioned si se dio); y serving. Un attach posterior reanudado vuelve a ejecutar los rechazos distintos de los de una celda nueva y continúa desde el primero de estos pasos no realizado; las ubicaciones son idempotentes gracias a la lectura de vuelta. Sus personas son aprovisionadas por su propia aplicación del proveedor de identidad antes de iniciar sesión. Los servicios propios de una org se adjuntan como una celda propia. Una nueva org de personas comienza con loom cell place --org, y luego la asignación de sus personas a las aplicaciones de esa celda; una celda con SCIM activado no admite a nadie hasta que se haya ejecutado su primer ciclo de aprovisionamiento. Una celda que se acerca a los límites de sus almacenes se cierra a nuevas orgs: sus llamadas de ubicación responden 503, de modo que las nuevas orgs de sus emisores esperan capacidad en lugar de derramarse a otra parte.

Un primer attach reanudado, para una celda cuya fila del directorio tiene attach_started_at, vuelve a ejecutar cada rechazo de la lista anterior que se aplique a la primera celda. Luego continúa según el modo de la celda: en recording desde el paso 1; en enforced, desde la espera del paso 3 (cada proceso activo informa enforced, luego pasan la vida de la caché y el plazo de solicitud más largo) y después su precondición SCIM, de modo que la comprobación SCIM que cierra un attach detenido tras establecer enforced, sea cual sea la causa, siempre se ejecuta después de que enforced haya surtido efecto.

Qué ejecuta cada celda

Todo lo que ejecuta un despliegue, sin cambios: sus pools, migraciones, workers y sus leases, health y readiness (la readiness de un pod es la de su celda), el borrado y su censo, los checkpoints de auditoría, los backups y las restauraciones. La restauración de una celda es la de un único despliegue (copias de seguridad y recuperación), con los mismos límites: lo que contiene el backup (sus claves, revocaciones, sesiones, bots y filas de SCIM) vuelve tal como estaba. Una celda añade un paso después de la restauración del almacén y antes de cualquier otro paso de esa página: loom cell restore, con la celda detenida, ejecutado donde el operador ejecuta loom cell place y attach, con la credencial de operador del router, que ninguna configuración de celda contiene (un comando de CLI declarado sin organización: escribe las filas propias de la celda), reescribe desde el directorio las filas que una restauración puede recuperar, de modo que los borrados y las redacciones de loom reconcile pasen la comprobación de tenencia, y una restauración de ambos almacenes, que loom reconcile rechaza, aun así recupera las filas de su celda. Se rechaza mientras el directorio no está disponible, y escribe:

  • una fila de tenencia por cada organización que el directorio ubica en ella;
  • la que falte entre la fila first y la fila de modo, tomada del directorio, como hace un prepare reanudado; una fila first presente que difiere de la del directorio se rechaza, y una que coincide se conserva;
  • una vez recuperadas las filas de tenencia, el modo registrado en el directorio sobre la fila de modo, solo hacia arriba (recording a enforced), nunca hacia abajo;
  • una vez que la fila del directorio contiene la huella de la celda (la escribe attach), su loom.cell_self a partir de ella (current y next); antes de attach el directorio no contiene ninguna, y el loom.cell_self restaurado queda como lo contiene el backup (un current ausente lo escribe una nueva ejecución de loom cell prepare cuando la celda arranca, un next perdido, volviendo a ejecutar loom cell update --config).

Una primera celda restaurada a un punto anterior a su prepare, y todavía no conectada, no sirve nada en el host compartido en sus procesos con LOOM_CELL definido (uno sin definir sirve como un único despliegue, como antes del despliegue gradual) hasta esa nueva ejecución de loom cell prepare, que es el paso inmediatamente posterior a su arranque.

La readiness de una celda nunca espera al directorio, así que una caída de este no detiene el rollout de ninguna celda. Un proceso que lee recording registra una organización nueva solo mientras el directorio responde que su celda está en attaching (las claves del heartbeat); mientras el directorio no se puede leer o marca la celda como serving, una organización nueva recibe 503 y las organizaciones que la celda contiene siguen sirviéndose. Por tanto, una restauración a un punto anterior al paso 3 del primer attach cuyo loom cell restore se omitió no sirve ninguna organización que no contenga; loom doctor nombra esa celda, y loom cell restore eleva su modo.

El directorio es un almacén de alta disponibilidad. Su Postgres funciona con un standby síncrono y recuperación a un punto en el tiempo hasta su último commit, igual que el de una celda, de modo que una conmutación por error o una corrupción no pierde nada confirmado. Perderlo por completo es una interrupción que falla en modo cerrado: cada celda sigue sirviendo las organizaciones que contiene, el enrutamiento continúa desde la instantánea firmada de cada réplica del router de su última caché (escrita en almacenamiento compartido en cada cambio del directorio), y las ubicaciones, las búsquedas de organizaciones no almacenadas en caché, los comandos loom cell que leen o escriben el directorio y las lecturas de estado de las celdas en modo recording responden 503 o se rechazan hasta que el directorio vuelva, mientras que loom doctor informa de sus comprobaciones del directorio como no ejecutadas y, con LOOM_CELL definido, termina con código distinto de cero; reconstruir un directorio perdido a partir de las celdas es un diseño aparte.

Cada celda conserva, en su propio Postgres, una copia de la huella de configuración de la fila de su directorio (loom.cell_self), con la que sus procesos comparan su configuración y que escriben attach y loom cell update (La fila propia de la celda). loom cell restore reescribe su loom.cell_self desde el directorio; los almacenes restaurados conservan el id de despliegue de la celda, así que una restauración a un nuevo endpoint solo necesita la nueva dirección en la configuración de la celda. Cerrar una celda o fijar su placements_max es un solo comando, loom cell limit --cell <cell> [--closed | --open] [--placements-max (<n> | none)], que escribe solo en el directorio, con la credencial de operador del router y sin ninguno de los almacenes de la celda, así que funciona mientras la celda está caída; el router juzga una ubicación a partir de la fila del directorio.

Operaciones

  • loom cell restore, después de cualquier restauración de almacenes y antes de loom reconcile, vuelve a escribir las filas de la celda desde el directorio (Qué ejecuta cada celda).
  • loom cell which --org <org> indica la celda de una organización (el borrado, la restauración y el soporte empiezan ahí); para una organización sin asignación indica la primera celda, y la búsqueda no distingue ese caso.
  • loom cell limit --cell <cell> --closed cierra una celda a nuevas organizaciones, --open la reabre y --placements-max <n> fija su cuota de asignaciones (--placements-max none la elimina).
  • loom cell remove --cell <cell> elimina la fila del directorio de una celda que está en attaching sin ninguna asignación (--cell es el LOOM_CELL de la celda, que para entonces ya no está definido). Para la primera celda lee únicamente el Postgres de la celda, en una sola sesión desde LOOM_PG_DSN y sin ClickHouse, y se niega a continuar a menos que lea open y registre el id de despliegue de la fila, lo que impone el orden de retroceso: quitar LOOM_CELL en cada proceso (cada uno funciona como en recording), después la limpieza completa del estado y por último la eliminación (solución de problemas). Si se elimina primero la fila, cada organización nueva recibe 503; si se limpia primero el estado, se bloquea cada proceso que tenga LOOM_CELL definido. Una primera celda con una asignación avanza, nunca retrocede. Los almacenes de una celda eliminada conservan las filas de estado que contengan, así que la limpieza completa del estado se ejecuta antes de volver a prepararlos.
  • La credencial de operador del router es lco_ seguida de 128 caracteres hexadecimales en minúscula (un router sin LOOM_ROUTER_OPERATOR_SHA256 responde 503 a la API de operador con NO_OPERATOR_CREDENTIAL), que genera loom cell credential new --operator; el router solo guarda su SHA-256. Las negativas de la API de operador no tienen límite de frecuencia: un límite por dirección permitiría que un desconocido detrás de un ingress compartido bloqueara a todos los operadores, y 512 bits no se adivinan en línea. Un comando de operador solo conoce su resultado cuando la conexión nunca se abrió o cuando respondió el propio router, salvo BACKEND_UNAVAILABLE (un COMMIT puede completarse después de su límite de tiempo); tras un tiempo de espera agotado, una conexión interrumpida o la página de una pasarela, indica que el cambio puede haberse realizado y qué muestra un reintento. La credencial de operador se rota definiendo el nuevo hash en LOOM_ROUTER_OPERATOR_SHA256 y reiniciando el router; mientras se renuevan sus réplicas, algunas siguen rechazando la nueva credencial con 401, y el operador vuelve a ejecutar el comando hasta que todas las réplicas la acepten. Los comandos llaman al router en --router, o si no en LOOM_CELL_ROUTER_URL, en su raíz (se rechaza una ruta ahí, porque el router reenvía una a una celda), y envían la credencial de operador solo por https (http en loopback), de modo que una dirección de router http dentro de la red sirve a una celda pero no a estos comandos.
  • loom cell credential new genera una credencial de router sin conexión y la imprime con su SHA-256; loom cell credential --cell <cell> --next <sha256> registra el SHA-256 de una nueva credencial de router como el hash next de la celda; igual que prepare, recibe el hash como argumento, en la misma forma. Usa la credencial de operador del router, escribe solo en el directorio y mantiene el bloqueo del directorio; se rechaza cuando alguna celda registra ese hash como actual o como siguiente, y mientras haya un next pendiente. El router acepta ambos en las llamadas de asignación y en las lecturas de estado, cada réplica dentro de LOOM_ROUTER_DIRECTORY_CACHE_S desde --next, por lo que la nueva credencial se incorpora a los pods solo después de ese plazo; loom router migrate se ejecuta antes de un router que lee el hash next, y una rotación empieza cuando todas las réplicas del router lo hacen. Un router revertido a una versión que lee solo el hash actual rechaza a un pod con el siguiente: revierte sin ningún next pendiente (primero --revert), y no entre --finish y el momento en que la credencial antigua sale de los pods. Cuando la nueva credencial está en los pods de la celda y, mientras el modo de la primera celda es recording, en su configuración de la CLI, loom cell credential --cell <cell> --finish convierte next en el actual y descarta el anterior; no comprueba nada que no pueda ver (el router no sabe qué credencial tiene un pod), y una celda finalizada demasiado pronto falla en modo cerrado: sus llamadas de asignación y lecturas de estado responden 401, como muy tarde cuando caduca la caché del router con los hashes de la celda (LOOM_ROUTER_DIRECTORY_CACHE_S), hasta que sus pods tengan la nueva credencial o hasta que el hash antiguo se registre de nuevo con --next y se finalice. loom cell credential --cell <cell> --revert descarta un next pendiente, de modo que uno equivocado o filtrado nunca tenga que finalizarse; --finish y --revert se rechazan si no hay ningún next pendiente.
  • La configuración de una celda nueva indica LOOM_CELL, su host público (LOOM_PUBLIC_BASE_URL, LOOM_OAUTH_ISSUER, LOOM_JWT_ISSUER), sus claves, su prefijo de bucket, sus organizaciones configuradas, el cliente OIDC y el token SCIM de su proveedor de identidad, y su credencial de router (LOOM_CELL_ROUTER_URL, LOOM_CELL_ROUTER_TOKEN, que mantienen sus pods, y LOOM_CELL_ROUTER_TIMEOUT_S).
  • Cada celda informa de escrituras por segundo, filas por espacio de nombres y bytes por clave en /v1/health?include=capacity, frente a unos 13.6 KB por clave en ClickHouse y 6.8 KB en Postgres (Memoria a escala).
  • Una organización permanece en su celda. Mover una organización entre celdas es un diseño aparte: requiere aislar las escrituras de la organización en cada proceso de la celda, una copia de cada almacén que no cuente nada dos veces y una eliminación verificada.
  • Los datos de una celda permanecen en sus almacenes. Moverlos a otros almacenes (otro id de despliegue, nombre de bucket o prefijo), o añadir un bucket a una celda preparada sin uno, es un diseño aparte: durante cualquier despliegue gradual los procesos antiguos y los nuevos escribirían en almacenes distintos, así que requiere aislar las escrituras de la celda, como en el traslado de una organización.
  • Una celda permanece conectada. Retirar una celda es un diseño aparte: requiere una prueba, obtenida de los propios almacenes, de que no queda ninguna copia de los datos de sus organizaciones, antes de que nada pueda responder que así es. Hasta entonces, una celda que está caída sigue siendo una celda: sus organizaciones responden 503, y sus nombres, emisores, hosts y asignaciones siguen reservados.

Modos de fallo

Fallo Qué ocurre
El directorio está caído se enrutan las solicitudes por host, por emisor y a la primera celda; las organizaciones nuevas y las búsquedas no almacenadas en caché responden 503
Falla la llamada de colocación del enrutador la solicitud responde 503 y no se escribe nada; se sirven las organizaciones que la celda contiene
El emisor de una celda coloca organizaciones en avalancha desde enforced, sus llamadas de colocación responden 503 con Retry-After por encima de su tasa, y sus llamadas para organizaciones nuevas responden 503 por encima de su cuota si hay una definida; las demás celdas colocan como antes
Un token SCIM de otra celda, o una aplicación en el host de la celda equivocada el proceso no arranca, o /scim/v2 responde 401 y no escribe nada
El Postgres o el ClickHouse de una celda esa celda falla igual que una implementación única (autoridad de almacenamiento); las demás celdas siguen sirviendo
Las filas propias de una celda o su modo de tenencia no se pueden leer con LOOM_CELL definido, un proceso conserva sus últimas filas y su último modo dentro del límite de obsolescencia y después queda bloqueado; un proceso de servidor cuya primera lectura falla no arranca (bloqueado y no listo con migraciones de Postgres pendientes), y un hijo de workers que nunca las leyó queda bloqueado; sin definirlo, un proceso de servidor conserva su veredicto sin límite, y una primera lectura fallida hace fallar su arranque (bloqueado hasta que una lectura tenga éxito con migraciones de Postgres pendientes)
Se elimina una fila first o de modo, o ambas junto a una fila de tenencia o propia los disparadores de organización, donde una celda los tiene, actúan como en enforced y todos los procesos quedan bloqueados; loom doctor lo señala y volver a ejecutar prepare las escribe de nuevo
Ninguna fila de estado, de tenencia o propia en una celda que el directorio registra abierto; loom doctor lo señala; loom cell restore lo cierra tras una restauración, y volver a ejecutar prepare lo cierra tras un prepare interrumpido
Aún no se lee el valor first de una celda toda solicitud, salvo las sondas de salud y la ruta de sondeo, responde 503 (SCIM con Retry-After); el proceso no está listo y no ejecuta ningún worker (un hijo de workers, o un proceso de servidor con migraciones de Postgres pendientes; cualquier otro proceso de servidor falla en el arranque)
Una solicitud para la organización de otra celda 409 WRONG_CELL tras la verificación, sin escribir nada
Una llamada de plataforma, de organización * o sin principal para una organización no contenida en una primera celda, 503 mientras el directorio responde attaching o no se puede leer antes de una respuesta serving; 409 WRONG_CELL una vez en serving y en una celda posterior
Un pooler que elimina el marcador de tenencia de las sesiones de una celda la comprobación de preparación cell_marker falla en enforced y partial y avisa en recording; el latido informa marked en false y attach rechaza el proceso
Una celda restaurada a un momento anterior loom cell restore vuelve a escribir las filas de las organizaciones colocadas antes de iniciarse
Una primera celda restaurada a antes de su prepare, aún sin adjuntar en los procesos con LOOM_CELL definido, toda solicitud salvo las sondas de salud y la ruta de sondeo responde 503 hasta que prepare se vuelve a ejecutar
El directorio perdido cada celda sirve las organizaciones que contiene; las colocaciones y las búsquedas no almacenadas en caché responden 503 y los comandos del directorio se rechazan, hasta que vuelva
Una celda en recording, con el directorio ilegible una organización nueva responde 503; las organizaciones que contiene siguen sirviéndose
Un proceso atascado durante el primer attach attach se rechaza tras --wait y la celda vuelve a recording
Un insert de recording retenido abierto durante el primer attach attach deja de intentarlo cuando queda muy poco de --wait para la espera e informa del modo que lee de vuelta; volver a ejecutarlo lo reanuda
Attach se detiene mientras retiene el bloqueo de la tabla de modo Postgres termina su sesión en pocos segundos y libera el bloqueo; las organizaciones nuevas responden dentro de su plazo
Una transacción abierta desde antes de la instantánea del paso 4 attach se rechaza cuando se agota --wait (una preparada, de inmediato), indica qué esperaba y deja enforced
Un comando de la CLI con LOOM_CELL sin definir, iniciado antes del paso 3 de attach leyó el estado mientras la primera celda estaba en recording y sigue escribiendo en ClickHouse después de serving; el runbook define LOOM_CELL en cada CLI antes de attach
Una CLI de una compilación anterior a la lectura del estado no se rechaza en una celda enforced; cada imagen de CLI y de CI ejecuta una compilación con la lectura antes de attach (actualizaciones)

Actualizaciones progresivas

La comprobación de tenencia, la llamada de colocación y la lectura del estado de la celda, las declaraciones de organización de la CLI, LOOM_CELL, loom cell prepare, scim.refuses_subject, el correo electrónico que almacena una concesión, loom.cell_self, la compuerta de solicitudes y la comprobación de preparación de la huella de un proceso frente a su propia fila, el rechazo del token SCIM de otra celda, el requisito de SCIM, y el modo, la huella y LOOM_CELL del heartbeat se publican en una misma versión. La compuerta sobre un proceso con LOOM_CELL sin definir, el marcador de sesión y los triggers de organización se publican juntos en una misma versión; el prepare de una primera celda admite un proceso de la versión anterior, que atiende mientras la celda está en recording, y loom cell attach, que se publica en una versión posterior y lee su propia clave de heartbeat, se niega hasta que todos los procesos activos ejecuten esa versión, de modo que el único rollback admitido desde una celda adjunta llega a una compilación que envía el marcador. La migración de los triggers de organización es aditiva, y los triggers no hacen nada en un despliegue que nunca se preparó (sin filas de estado, la regla de la fila first). Con LOOM_CELL sin definir, un proceso lee solo las filas de modo y first y si existe una fila de tenencia o propia, y solo bajo la autoridad de Postgres, donde un despliegue que nunca se preparó no tiene ninguna (las tablas se crean vacías), de modo que las compilaciones N-1 y N atienden lado a lado sin cambios. El router enruta por host, emisor y la primera celda, nunca por las ops de una celda, de modo que la versión de una celda no espera a la del router, salvo por la que nombra el párrafo siguiente.

Las claves junto a la huella de un heartbeat (las claves del heartbeat) son las claves de heartbeat propias de la versión de attach: una compilación anterior a ellas lee solo la versión y los campos de una huella, por lo que acepta tal cual el heartbeat de una compilación más reciente, y attach rechaza un proceso que no reporta ninguna. Esa versión espera a la de los routers: cada réplica del router la ejecuta antes que los procesos de cualquier celda, ya que una primera celda preparada consulta la ruta de estado desde su primera lectura del estado de la celda hasta que lee serving, y solo un router de esa versión la responde desde su caché (actualizaciones).

Invariantes

  • Un org es atendido por exactamente una celda, la que nombra su ubicación (placement), y su ubicación nunca se elimina ni se modifica.
  • Un proceso con LOOM_CELL definido no responde nada salvo sus sondas de salud y la ruta de sondeo, y no ejecuta ningún worker, a menos que su configuración coincida con un valor de la fila propia de su celda, que las negativas por solapamiento del directorio ya han comprobado; un proceso con LOOM_CELL sin definir en una celda cuyas filas de estado cuentan como enforced o están en un estado partial (la regla de la fila first) no responde nada salvo sus sondas de salud y la ruta de sondeo, y no ejecuta ningún worker.
  • Ninguna celda acepta el mismo emisor de bearer token, host, cliente OIDC, patrón de org o prefijo de bucket que otra, y ningún id de despliegue ni credencial de router es poseído por dos celdas.
  • Toda ruta de seguridad falla de forma cerrada, con cuatro excepciones. Primera, un proceso de servidor con LOOM_CELL sin definir mantiene su veredicto ante lecturas fallidas de las filas de estado sin límite de obsolescencia: abierto en open y recording, como lo es la interrupción parcial de un despliegue único, y bloqueado en cualquier otro estado; si falla la primera lectura, falla su arranque, o, con migraciones de Postgres pendientes, queda bloqueado hasta que una lectura tenga éxito. Segunda, una celda registrada sin fila de estado, de tenencia (tenancy) ni propia (su Postgres restaurado a un punto anterior a su prepare, o un prepare detenido antes de escribir su fila), que está abierta hasta que se ejecute loom cell restore (tras una restauración) o se repita el prepare (tras un prepare detenido) y que loom doctor nombra mientras tanto: una fila, un modo o un valor de first ilegibles se rechazan; con el directorio inaccesible, las ubicaciones, las búsquedas no almacenadas en caché, los comandos loom cell que lo leen o escriben y las lecturas de estado de las celdas en modo recording se rechazan, mientras cada celda sigue atendiendo los orgs que posee. Tercera, un arranque con migración que no puede crear o habilitar un trigger de org o la guarda loom.tenancy en una tabla, o devolver a always los triggers de loom.cell_first (su bloqueo no se obtiene en tres intentos de 100 ms, o una tabla que el rol no puede alterar), lo registra y sigue sirviendo, dejando esa tabla sin guarda hasta que un arranque posterior tenga éxito: los triggers son solo un respaldo frente a escritores que no envían marcador, rechazar el arranque dejaría caída una celda por un respaldo, y attach rechaza un trigger ausente. Cuarta, un comando de revocación sin org que no puede devolver el acceso (un loom revoke-token simple, no uno que restringe o hace caducar, la revocación de un usuario SQL, loom signing-key retire, loom bot disable, loom sso unlink) con LOOM_CELL definido, cuya lectura de la fila first de la celda falla porque Postgres no responde, se ejecuta e imprime que la celda no fue comprobada, ya que una revocación debe funcionar durante una interrupción; cualquier otra lectura fallida, incluida la falta de un permiso (grant), se rechaza.

Puntos de entrada del código fuente

  • server/core/cell_probe.py: la ruta de sondeo y el listener de sondeo, que todo proceso web acepta y que el proceso hijo de los workers nunca abre;
  • server/core/cell.py: el estado propio de la celda (loom.cell_first, loom.tenancy_mode, loom.cell_self), la regla de estado del despliegue (state, sobre las filas que lee refresh, incluido si loom.tenancy contiene alguna fila entre ellas), su huella y gate_reason, la compuerta en los procesos con LOOM_CELL definido o sin definir, que el middleware de solicitudes (server/transport/model_maintenance.py), verify_token, la disponibilidad (readiness), el lease de los workers y la lectura del heartbeat; start_cell_gate de server/boot.py es la lectura de arranque de un proceso del servidor;
  • server/core/cell_triggers.py: el marcador de los triggers de la organización, ensure (la creación y reparación de los triggers y de la protección de loom.tenancy que hace un arranque con migración) y missing (lo que loom doctor nombra), con sus funciones en schemas/pg_migrations/011_tenancy_triggers.sql y 012_tenancy_guard.sql; server/cli/doctor_cell.py: las comprobaciones de celda de loom doctor;
  • server/cli/cell_scan.py: el escaneo de organizaciones del primer attach, una biblioteca que ningún comando invoca: las tablas de ambos almacenes con una columna org, juzgadas por motor y según la clasificación del borrado, con todos los hosts de un clúster listando lo mismo, y las organizaciones distintas de cada tabla fuera de LOG_TABLES; server/cli/cell_writers.py: la comprobación de escritores de ClickHouse (los usuarios, directorios de usuarios, objetos y réplicas que quedan fuera de las listas permitidas del operador); server/cli/cell_ch.py: lo que ambos comparten (los hosts del clúster, las lecturas por host);
  • schemas/pg_migrations/008_cells.sql, schemas/pg_migrations/009_cell_probe.sql y schemas/migrations/094_cell_heartbeats.sql: las tablas de la celda;
  • server/auth/tenancy.py (ensure_held): la comprobación de tenancy y la llamada de ubicación (placement), ejecutadas por la compuerta de ops (server/transport/gates.py), check_authorized, admit_org y las rutas que nombran una organización; server/transport/tenancy_gate.py comprueba la organización propia del token en las rutas fuera del registro que actúan en ella, y tests/unit/test_cell_tenancy.py contiene el censo de todas las rutas;
  • server/router/app.py (loom router serve): la API de ubicación, la lectura de estado de la primera celda (que server/core/cell_router.py realiza sobre una primera celda), el enrutamiento por las reglas 1 a 4 (server/router/routing.py, que decide, y el reenvío), la consulta de organización con su caché de organizaciones ubicadas (que loom login --org, loom.credentials.org_server, consulta), sus límites de tasa (server/router/limits.py) y las comprobaciones que supera una ubicación; su API de operador, con las rutas de attach de la primera celda, que loom cell limit, loom cell credential y loom cell remove (server/cli/cell.py, con loom cell which) invocan con la credencial de operador del router (LOOM_ROUTER_OPERATOR_TOKEN; el router solo conserva LOOM_ROUTER_OPERATOR_SHA256); server/router/directory.py y schemas/router_migrations/: el directorio, en la base de datos Postgres propia del router (LOOM_ROUTER_PG_DSN, loom router migrate).

El resto del código de la celda lo añaden los pull requests que implementan esta página. Se apoya en:

  • server/auth/jwt.py (verify_token, AuthUnavailable): donde la compuerta de huella se ejecuta primero;
  • server/auth/scim.py (tokens) y server/auth/scim_routes.py (scim_settings_problem, _authorized): el analizador de tokens SCIM y sus comprobaciones;
  • server/core/instances.py: el heartbeat que informa del modo, la huella, LOOM_CELL y las claves junto a la huella;
  • server/workers/leader.py: el lease del que se aparta un proceso bloqueado por la compuerta;
  • server/core/pg.py (same_deployment): el id de despliegue que llevan ambos almacenes;
  • server/transport/gates.py (resolve_org, authorize): donde se ejecuta la comprobación de tenancy;
  • server/cli/_ch.py (run_connected, connect_checked, connect_declared): las declaraciones de organización de la CLI, que tests/unit/test_cell_cli_orgs.py exige a cada conexión;
  • server/auth/authz.py (check_acted_for, _check_creator) y server/auth/oauth.py (_refresh_session): las comprobaciones SCIM al actuar y al refrescar;
  • server/identity/app/scim_groups.py (_caller): la segunda ruta SCIM.

Rechazado

  • Un plano de control compartido por las celdas (un único conjunto de claves, permisos y workers, con los datos divididos por organización): una comprobación de seguridad, un lease de worker, un borrado, una generación de políticas y la cadena de auditoría abarcarían varios almacenes, y cada división necesitaría un protocolo propio.
  • Asignar una organización en su primera solicitud, antes de la verificación: cualquiera podría elegir la celda de una organización, y un token emitido en una celda podría dirigirse a una organización asignada a otra.
  • Una lista de las rutas que crean una organización, cada una asignándola: las organizaciones surgen por más rutas de las que una lista puede mantener al día (tokens de gateway y federados, bots, importaciones); la comprobación verificada es el único punto por el que pasa toda solicitud.
  • Redirigir un flujo de una celda a otra a mitad de camino: el cliente, los códigos y los refresh tokens de un flujo viven en la celda que lo inició.
  • Que el router guarde los usuarios del proveedor de identidad para todas las celdas: el alcance de cada correo electrónico en cada celda, una versión que sobreviva a la pérdida del directorio, los envíos y las recepciones serían cada uno un protocolo propio, cuando el proveedor de identidad ya desaprovisiona todas las aplicaciones asignadas a una persona.
  • Que cada réplica acceda a los almacenes de todas las celdas: un pool por réplica y por celda, el coste que rechaza Una base de datos por tenant.
  • Enrutar por espacio de nombres dentro de una organización: una operación que afecta a toda la organización (su borrado, los ids resueltos entre espacios de nombres, el uso compartido) abarcaría varias celdas; una organización grande obtiene su propia celda.

Pruebas

Una prueba de integración con dos celdas y un router en el job de Postgres de CI:

  • una solicitud verificada de una org nueva en cada celda la coloca una sola vez bajo solicitudes concurrentes, y la otra celda responde WRONG_CELL; una org emitida por un gateway, una org prefix* del emisor de un usuario final y la org de un bot se colocan del mismo modo tras enforced, y la solicitud de un principal de plataforma por una org no retenida no coloca nada;
  • cada ruta, incluidas las entradas de lote de MCP y todos los comandos de la CLI, rechaza la org de otra celda y no escribe nada en su Postgres ni en su ClickHouse (los censos de rutas, de campos de op y de la CLI cubren el resto);
  • el primer attach coloca todas las orgs con una fila en cualquier tabla; una org vista por primera vez durante el attach se coloca en el paso 4, y también la que escribió una inserción directa en Postgres entre la instantánea del paso 2 y enforced, una fila de ClickHouse escrita entonces por una CLI más antigua y un objeto de bucket catalogado entonces; un proceso que supera LOOM_JWT_REVOCATION_MAX_STALE_SECONDS de lecturas fallidas de sus propias filas o de su modo queda bloqueado y vuelve a servir cuando una lectura se completa; un pod con LOOM_CELL sin definir queda no listo, nombrando el ajuste, responde 503 a una solicitud con bearer, pasa su sonda de salud, responde a la ruta de sonda y no ejecuta ningún worker en una celda adjuntada y en una celda posterior entre prepare y attach, sigue sirviendo en una primera celda en recording y conserva el último modo que leyó pese a una lectura fallida, recording incluido tras el paso 3 o el paso 4 que devolvió la celda a ese modo; un comando de la CLI que declara una org con ese valor sin definir se rechaza en una celda enforced o partial, uno sin org (una revocación de token) se ejecuta, también con Postgres caído en un despliegue nunca preparado, y un comando de almacén loom cell se rechaza; loom cell limit --closed tiene éxito con el Postgres de la celda caído; tras loom cell credential --cell <cell> --next ambas credenciales colocan y leen estado, --finish rechaza la credencial antigua, para una celda finalizada antes de que sus pods tengan la nueva el router rechaza sus llamadas con 401, su solicitud responde 503 sin escribir nada y se recupera registrando de nuevo el hash antiguo, --revert descarta un next pendiente, que entonces se rechaza, y la credencial antigua sigue colocando, y se rechazan un segundo --next mientras hay uno pendiente y un hash que otra celda registra como current o next; loom cell limit y loom cell credential --next, --finish y --revert se rechazan mientras el directorio no está disponible; las colocaciones concurrentes con uno por debajo de placements_max en dos réplicas del router escriben una; un comando de la CLI que declara una org con LOOM_CELL_ROUTER_TOKEN definido se rechaza, nombrándolo, en una primera celda una vez enforced (attaching incluido) y en una celda posterior, y en una primera celda en recording se ejecuta y registra la org; el attach con placements_max por debajo de las orgs que retiene la primera celda las coloca todas, y el attach de una celda posterior que supera su cuota o está cerrada se rechaza, nombrando la org; una primera celda con --closed y placements_max definidos antes del paso 2 se adjunta, y una org que una solicitud registra entre el paso 2 y enforced la coloca el paso 4 sin 503; tras la escritura del modo de la celda en el paso 3, un proceso cuya caché aún lee recording envía la solicitud de una org nueva a la llamada de colocación, que una celda cerrada responde con 503; un comando de la CLI cuya inserción encuentra enforced se rechaza, nombrando la org, y no hace ninguna llamada de colocación; después de que la espera rechazada del paso 3 o la nueva comprobación del paso 4 devuelva la celda a recording, una org nueva se registra sin llamada de colocación, y una en un proceso cuya caché aún lee enforced se coloca a través de la puerta hasta que la caché expira; cada orden de la escritura del modo por el attach con una inserción de registro se mantiene como se indicó arriba (en ejecución, iniciándose durante la escritura, un flujo de inserciones solapadas cada una más corta que un intento, con el attach definiendo enforced en uno o dos intentos, retenida durante varios intentos, retenida hasta que queda muy poco de --wait, un attach detenido, una confirmación cortada por su timeout, una confirmación cuya conexión se pierde mientras espera al standby, leída de nuevo solo cuando ese backend ha desaparecido y escrita otra vez de forma duradera si lee enforced); una transacción REPEATABLE READ cuya primera sentencia se ejecutó antes de que enforced se confirmara, con el rol del attach o un segundo rol, retiene el paso 4 hasta que termina y su escritura de una org no retenida se coloca entonces, una cuya primera sentencia se ejecutó después se rechaza por el trigger, una transacción que empieza después de que el attach toma el bloqueo pero antes de que su confirmación sea visible retiene el paso 4, una transacción abierta en recording que sobrevive al --wait de una ejecución retiene el paso 4 de la repetición, tras un rechazo y tras loom cell restore que elevó el modo, un worker de autovacuum sobre una tabla de loom no retiene el paso 4 y un background worker con una transacción abierta desde recording sí, una transacción preparada (tras un reinicio con max_prepared_transactions elevado durante la espera) hace que el paso 4 se rechace de inmediato, nombrándola, con el modo todavía enforced y una repetición rechazada hasta que se resuelva y el ajuste vuelva a 0, una transacción de escritura abierta en una segunda base de datos del mismo servidor retiene el paso 4 y se nombra, una lectura larga en el standby síncrono, o en un segundo standby, con hot_standby_feedback activado no lo retiene, ni tampoco una copia de seguridad base que se ejecuta durante él, una escritura retenida abierta en una conexión replication=database retiene el paso 4, y también una transacción REPEATABLE READ en una, abierta en recording y sin escribir nada antes de enforced, un volcado lógico largo (una transacción de solo lectura REPEATABLE READ) en la base de datos de la celda que supera --wait hace que el paso 4 se rechace, nombrándolo, con la celda dejada en enforced, y el attach de la primera celda sin pg_read_all_stats o con max_prepared_transactions por encima de 0 se rechaza antes del paso 1 con el modo todavía recording, mientras que el attach de una celda posterior no exige ninguna de las dos cosas; un trigger de org ausente o deshabilitado lo rechaza el attach y lo nombra loom doctor, una escritura para una org no retenida en una celda enforced cuya fila de modo se eliminó se rechaza y loom doctor nombra el estado; en esa celda un pod con LOOM_CELL sin definir queda no listo y no ejecuta ningún worker, y un comando de la CLI que declara una org con ese valor sin definir se rechaza, igual que un pod; actualizar, eliminar o truncar la fila first en una celda enforced se rechaza, también bajo session_replication_role = replica, y un trigger de la fila first ausente o deshabilitado lo rechaza el attach y lo nombra loom doctor; un proceso en ejecución con LOOM_CELL definido en una celda cuya fila de modo se elimina responde 503 a una solicitud con bearer y no ejecuta ninguna pasada de worker, y vuelve a servir después de que una repetición de loom cell prepare vuelva a escribir la fila mientras se ejecuta; una celda que el directorio registra sin fila de estado, de tenencia o propia la nombra loom doctor, sus procesos con LOOM_CELL definido siguen no listos, un proceso con él sin definir sirve como despliegue único, y loom cell restore vuelve a escribir ambas filas, con una celda adjuntada sirviendo de nuevo y una no adjuntada tras una repetición de prepare; una celda con ambas filas ausentes junto a una fila de tenencia, y una junto a solo su propia fila, hace que la función rechace una org no retenida (un arranque no crea ningún trigger allí), todos los procesos bloqueados y loom doctor la nombra, y una repetición de prepare vuelve a escribir las filas; una restauración solo de Postgres de una primera celda adjuntada a un punto anterior a su prepare la nombra loom doctor y la cierra loom cell restore; una repetición de prepare durante un loom cell update pendiente en una celda adjuntada, con procesos en ambos valores y loom.cell_self perdido, vuelve a escribir ambos valores y mantiene sirviendo ambos conjuntos de procesos, y una antes del attach rechaza las dos configuraciones; una repetición de prepare en una celda adjuntada cuyo current falta y cuya configuración de pods difiere de la fila del directorio se rechaza, y una antes del attach cuyos heartbeats informan de otro prefijo de bucket se rechaza; una repetición de prepare con un hash de credencial que no es ni el current ni el next de la fila se rechaza; una repetición de prepare en una celda posterior serving cuyo prefijo contiene datos vuelve a escribir una fila de modo eliminada; una celda con fila de modo y sin fila first hace que la función rechace una org no retenida (un arranque no crea ningún trigger allí), todos los procesos bloqueados y loom doctor la nombra, y una repetición de prepare vuelve a escribir la fila; una celda posterior cuya fila de modo se define en recording no registra nada, su trigger rechaza una org no retenida, un proceso con LOOM_CELL definido allí sirve como en enforced, un pod con LOOM_CELL sin definir allí queda no listo y no ejecuta ningún worker, loom cell prepare nombra la fila, un comando de la CLI que declara una org con LOOM_CELL_ROUTER_TOKEN definido se rechaza, nombrándolo, y el router rechaza su lectura de estado; el memory.set y la pasada de entrega de un proceso de la compilación N-1 en un despliegue nunca preparado tras la migración de N tienen éxito y no escriben ninguna fila de tenencia, y en la primera celda en recording un arranque no crea ningún trigger de org, y uno creado a mano lee el estado y no busca nada, una escritura bajo session_replication_role = replica para una org no retenida se omite (triggers de origen), un INSERT ... ON CONFLICT DO UPDATE que inserta una fila para una org no retenida se rechaza y uno que alcanza una fila existente de ella no, todas las escrituras de una sesión marcada pasan, y los triggers de una celda enforced cubren todas las tablas que erasure clasifica con una columna org salvo las tres exclusiones; y una escritura con clave de org mientras el attach retiene el bloqueo de la tabla de modo vuelve de inmediato, con las solicitudes de org nueva respondiendo dentro de su plazo y las lecturas de la caché de modo volviendo de inmediato durante todo el proceso; loom cell restore tras un rechazo en el bloqueo del paso 3 deja la celda enforced, y el attach reanudado se ejecuta desde la espera del paso 3; un LOOM_CELL_ROUTER_TOKEN que no tiene la forma lcr_ se rechaza en el arranque y lo nombra loom doctor; loom cell credential new imprime una credencial de esa forma y su SHA-256, con el directorio y los almacenes inalcanzables; prepare y --next rechazan un argumento que no sean 64 caracteres hexadecimales en minúsculas, incluidos la credencial y su secreto desnudo de 128 caracteres, sin almacenar nada; las orgs que una primera celda registra en recording sin datos las lista loom doctor; una avalancha de colocaciones sin cuota definida queda limitada por el límite de tasa en cada réplica del router, loom doctor nombra la celda como una sin cuota, y una llamada rechazada por encima de él en una réplica responde 503 con un Retry-After de como máximo 60 s, tras el cual su reintento en esa réplica, sin que se admita entre medias ninguna otra llamada de la celda, se admite; el primer prepare de una celda, sin fila de directorio todavía, pasa la comprobación del id de despliegue; un pod o CLI que perdió LOOM_PG_DSN o LOOM_STORAGE_AUTHORITY en una celda es rechazado por la comprobación de autoridad; los tokens, refresh tokens y clientes OAuth existentes de la primera celda siguen funcionando durante el cambio, un cierre de sesión a través del host compartido revoca su refresh token;
  • el attach rechaza un emisor compartido, un secreto raíz, una ruta de Keeper, un prefijo de bucket anidado o una org configurada compartidos, una segunda celda que contiene datos y un segundo attach mientras se ejecuta uno;
  • un inicio de sesión OIDC, la autorización de un cliente MCP y un device flow para una org de la segunda celda se completan en el host de esa celda tras una consulta; loom login --org mantiene su host ante NO_CELL y en un despliegue sin router, reintenta tras el Retry-After de un 429 hasta agotar --wait y entonces se rechaza como rechazo por tasa, y, mientras el directorio está caído, inicia su flujo en el host de celda de una org que el router tiene en caché y se rechaza, sin iniciar ningún flujo, para una que no;
  • con SCIM activado, una persona que el proveedor de identidad nunca asignó a una celda no puede iniciar sesión, refrescar, ser suplantada ni usar un token de gateway allí, una desactivación enviada a la aplicación de una celda termina a la persona allí, un bot administrador de plataforma sigue alcanzando una celda cuyo SCIM desactivó a todos, y el attach rechaza una celda con sujetos vivos sin aprovisionar o que comparte el cliente OIDC de otra;
  • un attach detenido en el paso 3 después de definir enforced, antes de que pasara la espera, se reanuda con la espera antes de la precondición de SCIM, y uno rechazado por la precondición de SCIM se reanuda también desde la espera, con el modo todavía enforced; un attach posterior rechazado antes de su transacción de directorio deja attach_started_at vacío, de modo que una repetición vuelve a comprobar los rechazos de una celda nueva, y un primer attach reanudado encuentra sus orgs configuradas colocadas en esta celda y continúa;
  • una celda restaurada a un punto anterior al enforced del primer attach recupera su modo con loom cell restore; una cuyo loom cell restore se omitió responde 503 para una org que no retiene, la org de otra celda incluida, no escribe ninguna fila de tenencia para ella y loom doctor la nombra; una caída del directorio durante el despliegue de LOOM_CELL y entre prepare y attach deja la primera celda sirviendo las orgs que retiene, con una org nueva respondiendo 503 en cada proceso con LOOM_CELL definido; la lectura de estado se acepta de una primera celda que está attaching antes del paso 2 del attach, y solo con la credencial propia de la celda nombrada, y una respuesta rechazada o tardía cuenta como ilegible;
  • un grant refrescado en N que se escribió en N-1 se comprueba contra la fila de la persona, un refresh mientras SCIM es ilegible responde 503 y conserva la sesión, y un proceso con LOOM_CELL definido antes de loom cell prepare sigue no listo;
  • un token delegado durante el primer attach por una persona nunca aprovisionada se rechaza tras enforced; un gateway que actúa por un bot se atiende y por un handle desnudo se rechaza;
  • con el directorio no disponible, cada celda sirve las orgs que retiene, las colocaciones responden 503, y loom doctor en una celda informa de sus comprobaciones de directorio como no ejecutadas y sale con código distinto de cero;
  • LOOM_CELL se despliega después de loom cell prepare con todos los pods listos, antes del attach;
  • preparar una celda vacía antes del despliegue del host compartido se rechaza, y una celda restaurada desde la instantánea de otra celda se rechaza en prepare;
  • un prepare interrumpido entre la escritura del directorio y la escritura de la celda, con LOOM_CELL ya desplegado, se repite a través de probe_url contra procesos bloqueados; una repetición de prepare antes del attach cuyos heartbeats no coinciden ni con el current ni con el next presentes se rechaza; una repetición de prepare adjuntada con solo next perdido lo vuelve a escribir, y una cuyo current presente difiere del directorio lo sobrescribe; una repetición de prepare en solitario tras una restauración solo de Postgres de una primera celda adjuntada a un punto anterior a su prepare deja a loom doctor nombrando las filas de tenencia ausentes, y un pod con LOOM_CELL sin definir sirve todas las orgs allí hasta la repetición y queda bloqueado después, mientras que con LOOM_CELL definido una org recupera su fila de tenencia a través de la llamada de colocación; una repetición de prepare contra pods con LOOM_CELL sin definir en estado partial alcanza su ruta de sonda y vuelve a escribir la fila ausente; prepare rechaza el probe_url de una celda posterior que informa de un id distinto del de sus almacenes, attach rechaza una celda cuyo host informa de un id distinto del de su probe_url, y prepare rechaza un argumento de dirección de sonda para la primera celda, y el router solo sondea LOOM_ROUTER_UPSTREAM_PROBE_URL; el primer prepare de una celda posterior tiene éxito; loom cell update --probe-url rechaza una dirección que informa de otro id de despliegue o falla el eco del nonce, y rechaza la primera celda; loom cell update mueve las direcciones de sonda y upstream de la primera celda solo cuando todas las réplicas del router las ejecutan, tras su sonda y la comprobación de id del upstream, y una repetición de prepare a través de una réplica todavía con los valores antiguos (o los nuevos, antes del cambio) se rechaza, nombrando la dirección de la fila; un probe_url con userinfo u otro esquema se rechaza; el puerto principal responde solo el id en memoria, con cualquier Host, sin leer ningún almacén; el router sondea un probe_url https cuyo certificado firma una CA de su SSL_CERT_FILE; el listener de sonda responde 429 por encima de su tasa; y un prepare con una copia de los almacenes de la primera celda se rechaza por el nonce;
  • la primera celda por defecto (LOOM_JWT_ISSUER=loom, un LOOM_OAUTH_ISSUER vacío) se adjunta; una celda redesplegada con el host compartido como su URL pública queda no lista;
  • una colocación insertada en la cuota de una celda cuya llamada agotó el tiempo se reintenta y responde a su ganadora, y la celda escribe la fila de tenencia; lo mismo en una celda cerrada entretanto, y para una repetición de loom cell place;
  • un attach que muere entre su escritura de directorio y su escritura de loom.cell_self se reanuda hasta serving, y sus emisores permanecen reservados mientras tanto; un loom cell place para una org que otra celda retiene no escribe ninguna fila, y uno para una org que el directorio no coloca se rechaza, sin escribir ninguna fila, para una celda cerrada, por encima de placements_max, para una celda posterior todavía attaching, para una primera celda antes de que el directorio registre enforced, con una configuración cuya huella no coincide con ningún valor de la fila de la celda, y mientras el directorio no está disponible, y no se rechaza una vez agotada la tasa de la celda ni cuenta para ella (las llamadas de colocación propias de la celda siguen admitiéndose tras una serie de place del operador); uno para una org que el directorio coloca en esta celda escribe su fila de tenencia en una celda cerrada o llena; loom bot create para una org nueva en una primera celda en recording registra la org mientras el directorio responde attaching y se rechaza mientras responde serving o no puede leerse;
  • un host de emisor OAuth que difiere del host público de la celda se rechaza en prepare, y el host compartido enruta antes de que se adjunte ninguna celda; un loom cell place sin otras escrituras mantiene la org en su celda;
  • una primera celda restaurada a un punto entre los pasos 1 y 3 del attach después de estar serving queda lista en enforced una vez ejecutado loom cell restore;
  • una celda restaurada a un punto anterior a un loom cell update --finish sirve de nuevo una vez que loom cell restore ha reescrito su propia fila, una celda cuyos dos almacenes se restauran recupera sus filas solo con loom cell restore, y una celda preparada y no adjuntada conserva su propia fila restaurada;
  • una primera celda restaurada a un punto anterior a su prepare recupera sus filas, responde 503 en el host compartido en los procesos con LOOM_CELL definido hasta que se repite loom cell prepare, y entonces sirve; SCIM en un despliegue con LOOM_CELL sin definir funciona como antes en N, durante prepare, el despliegue de LOOM_CELL y el attach;
  • el SCIM de la primera celda sigue respondiendo a su token sin nombre durante el cambio, una celda posterior rechaza un token sin nombre, ninguna celda acepta el token de otra, lsc_b_… y un token lsc_ mal formado se rechazan en la primera celda, y una celda posterior con una fila de SCIM escrita antes de LOOM_CELL se rechaza en el attach; un token de la celda a-b se rechaza en la celda a, y un nombre de celda con _ se rechaza;
  • una celda posterior con oidc_jit_org definido arranca y reinicia sus pods entre prepare y attach, con JIT para esa org respondiendo 503 hasta que el attach la coloca; el autoregistro de una primera celda en una org que ninguna solicitud ha registrado, entre prepare y attach, la registra y completa el registro; una celda posterior con repositorios indexados no escribe ninguna fila de código antes del attach y luego se adjunta; una primera celda en recording mantiene sus pasadas de worker para una org que ninguna solicitud ha tocado desde el despliegue; el attach de una celda posterior detenido tras attach_started_at se reanuda con sus orgs configuradas colocadas y retenidas; una actualización entre prepare y attach que cambia la org de código hace que el attach coloque esa org, y tras --finish indexa; una actualización posterior al attach rechaza una org configurada modificada que otra celda retiene, nombrándola, y, para una org que el directorio aún no coloca, se rechaza para una celda cerrada y por encima de placements_max; una actualización que cambia una org configurada de una celda posterior todavía attaching tras su transacción de directorio se rechaza hasta que la celda esté serving; --revert conserva una org configurada que la actualización colocó; las orgs de código y de tracker de una celda posterior sirven e indexan una vez que está serving, incluida una op code.* de un miembro de otra org, y también una org configurada que loom cell update cambia; un attach posterior que compite con la actualización de otra celda que amplía un emisor rechaza a una de las dos; una org configurada que otra celda coloca entre los rechazos del attach y su colocación hace que el attach se rechace, nombrándola, y no escribe nada; prepare rechaza una credencial de router que otra celda registra; una llamada de colocación que nombra a otra celda con una credencial válida de esta no coloca nada en la otra;
  • la llamada de colocación de una celda preparada y no adjuntada para una org que el directorio no coloca responde 503, una para una org que sí coloca responde a la ganadora incluso con la credencial antigua todavía en caché tras loom cell credential --finish o con una huella que no coincide con ningún valor, una ganadora con el nombre de esta celda bajo otro id de despliegue responde 503 y no escribe ninguna fila de tenencia, y un proceso cuya configuración difiere de la fila de su celda no coloca nada;
  • una celda adjuntada con SCIM desactivado y activado por loom cell update se rechaza mientras hay un token de registro de agente vivo, incluido uno emitido mientras la actualización se despliega, y un proceso configurado con el emisor de otra celda responde 503 a toda solicitud con bearer, alcanzada a través del router o directamente;
  • durante un loom cell update, los procesos con la configuración antigua y la nueva sirven ambos, --finish libera un emisor reducido solo cuando ningún proceso lo acepta, una actualización que muere tras su escritura de directorio mantiene reservado el emisor ampliado, y las compilaciones N y N+1 con una configuración coinciden con la misma fila;
  • rotar un token de SCIM no cambia ninguna huella; un proceso se niega a arrancar con el token de SCIM de otra celda, un proveedor de identidad apuntado al host de la celda equivocada recibe 401 y no escribe nada, y una celda revertida a N sigue bloqueando según su propia fila y rechaza el token de SCIM de otra celda; una avalancha de colocaciones del emisor de una celda se rechaza por encima de su cuota;
  • un gateway que actúa por la cuenta de servicio personal de una persona nunca aprovisionada se rechaza, y una celda que empieza a aceptar el emisor de otra celda no admite colocaciones;
  • un proceso que no coincide con ninguno de los dos valores de su fila responde 503 al inicio de sesión, el refresh, los endpoints de token y device de OAuth, el callback de inicio de sesión y el registro, y su ruta de sonda sigue devolviendo el nonce de prepare; --revert espera a los procesos que coinciden solo con next; update --config se rechaza mientras hay un next distinto pendiente, y una actualización que murió antes de su escritura de loom.cell_self se reanuda hacia delante; prepare se rechaza mientras hay un proceso anterior a N vivo; un cambio de configuración durante attaching pasa por loom cell update y el attach reanudado reserva ambos valores; un proceso cuyos almacenes configurados difieren de la fila de su celda responde 503 y se aparta de los workers, de modo que una compilación más nueva bloqueada junto a una más antigua sin bloquear deja los workers ejecutándose y borrando; loom cell update rechaza un cambio del id de despliegue, del nombre del bucket o del prefijo, añadir un bucket incluido; un proceso bloqueado en modo on no ejecuta ninguna pasada de worker; preparar un clon con el nombre de bucket y el prefijo de la primera celda se rechaza, en su endpoint o en cualquier otro; una celda posterior cuyo prefijo contiene objetos de otro despliegue se rechaza en prepare; dos prepares concurrentes de prefijos anidados no pasan ambos; dos celdas sin bucket se preparan ambas; prepare rechaza una celda posterior cuyo proceso lleva el LOOM_CELL de otra celda, y un proceso cuya fila first nombra a otra celda responde 503 y no ejecuta ningún worker; una avalancha en la ruta de id del puerto principal no detiene el attach; y una celda restaurada en un nuevo endpoint de Postgres, ClickHouse o bucket sirve una vez que su configuración lo nombra; una solicitud con bearer en el host compartido se atiende antes de prepare, entre prepare y attach, y durante el attach;
  • el chart no renderiza ningún listener de sonda por defecto, y con él activado renderiza el Service de sonda y no cambia ninguna NetworkPolicy, de modo que con la política del chart activada ninguna regla propia admite el puerto de sonda; prepare nombra PROBE_UNREACHABLE y PROBE_BUSY del router una vez agotado --wait; una avalancha en el puerto principal deja intacta la tasa del listener de sonda;
  • una celda posterior iniciada desde el entorno de la primera celda, con su bucket y prefijo, se ejecuta bloqueada desde su primer arranque y no borra ningún original; prepare rechaza una celda posterior mientras un proceso vivo carece de LOOM_CELL;
  • loom cell limit --closed hace que las llamadas de colocación de la celda respondan 503 mientras sigue sirviendo las orgs que retiene, --open las restaura, y --placements-max surte efecto en la siguiente llamada de colocación;
  • una restauración de Postgres de una celda enforced a un punto anterior a la colocación de una org, con esa org borrada después de ese punto, se reconcilia con salida 0 tras loom cell restore y luego sirve la org;
  • una celda restaurada desde antes de la colocación de una org la sirve una vez lista, un borrado deja la colocación de la org, y con el directorio perdido cada celda sirve las orgs que retiene.