Esta tarde, por primera vez, un motor de rutas de verdad nos planificó un viaje en autobús: línea 06-2, 2.071 segundos de puerta a puerta, frente a 2.585 andando. Ocho minutos y medio de ahorro. No es una goleada, pero es un autobús, y ha salido de un horario que escribimos nosotros.

Ese horario es un feed GTFS, y llevamos intentando publicarlo cada mañana laborable desde marzo. Hasta hoy, nada en Cuando le había pedido nunca un autobús. Este post va de los cinco meses entre medias, del único día largo que costó cerrarlos y de lo verde que se veía todo durante todo ese tiempo.

Por qué un motor de rutas

La cuarta parte terminó con la búsqueda de rutas funcionando en la memoria del Worker: un grafo de paradas y aristas, y un bucle que enumera los caminos con dos transbordos como mucho. Funciona. Pero primero encuentra las rutas y después pregunta al horario. Enumera caminos candidatos contando paradas y transbordos, luego mira cuándo salen sus autobuses y los ordena por tiempo total, esperas incluidas. Un camino que nunca enumeró no puede ganar, por pronto que salga su autobús.

Un planificador de transporte público lo hace al revés. Busca en el propio horario, así que una ruta con veinte minutos de espera pierde frente a un viaje más largo que sale ahora.

Ya teníamos uno funcionando. Valhalla es un motor de rutas de código abierto, y desde el pasado noviembre calcula los tramos a pie de nuestras rutas. Corre en una VM pequeña que ya teníamos, la misma máquina que dibuja las teselas (tiles) del mapa de la segunda parte. Valhalla también sabe calcular rutas en transporte público. Solo hay que darle GTFS.

Un horario que nadie publica

GTFS es el formato en que los operadores de transporte publican sus horarios: un zip de ficheros CSV. stops.txt dice dónde están las paradas y routes.txt enumera las líneas. trips.txt tiene una fila por cada recorrido de autobús, stop_times.txt dice cuándo llega cada recorrido a cada parada y calendar.txt dice qué días. shapes.txt dibuja la calzada por la que va el autobús. Todos los motores de rutas lo leen. Que sepamos, nadie publica uno para Torrevieja.

Pero tenemos todo aquello de lo que está hecho un feed GTFS. La red dibujada a mano de la primera parte da las paradas, las líneas y sus trazados. Los patrones de horario («desde C/ Mayor a las 07:30, cada 30 minutos, hasta las 20:01, laborables») dan las salidas. Y el truco de la primera parte, una hora de salida más los segundos de cada parada a la siguiente, da cada llegada. stop_times.txt es esa aritmética, escrita para cada salida y cada parada. Simplificado un poco:

for (const dep of departures) {
  const vec = vectors.get(`${dep.line}:${dep.from}`) // seconds from each stop to the next
  let t = dep.departure_time * 60
  for (let i = 0; i < vec.length; i++) {
    t += vec[i] // vec[0] is 0 for the first stop
    stopTimes.push({
      trip_id: tripId,
      stop_id: lineStations[fromIdx + i],
      arrival_time: formatTime(t),
      departure_time: formatTime(t),
      stop_sequence: i + 1,
    })
  }
}

Es JavaScript normal y corriente en el Worker, más una pequeña librería de zip. Como dice la cabecera del fichero, «aquí nada necesita un binario, un contenedor ni un runner de GitHub Actions».

Escribí la primera versión el 6 de marzo. Cada día laborable a las 04:20 UTC, el Worker genera el feed y lo sube a R2, pero solo si su hash ha cambiado. Diez minutos después, un cron en la VM tenía que comprobar el hash, descargar el zip si era nuevo, descomprimirlo para Valhalla y reiniciarlo. El feed está detrás de un token, porque las paradas, las líneas y los trazados que lleva son datos que recogimos a mano.

En el mismo commit, el Worker recibió una función que pide a Valhalla una ruta en autobús y a pie.

Nada la llamaba.

La app siguió preguntando a la búsqueda en grafo de la cuarta parte, y el feed siguió saliendo cada mañana laborable, o intentándolo. Hoy apuntamos la búsqueda de rutas a Valhalla y empezamos a descubrir qué habíamos estado publicando.

Todas las luces en verde

Esto es lo que se interponía entre el feed y un autobús en la app.

Lo primero, al menos, parecía roto. Generar el feed significa convertir cada salida en un recorrido y cada recorrido en una fila por parada, y luego comprimirlo todo, y todo eso tenía que caber en una sola ejecución del Worker. Cuando no cabía, la ejecución moría a medias, nada registraba cómo había terminado y nuestra lista de tareas la marcaba como «huérfana». R2 conservaba lo que hubiera escrito la última ejecución buena. Ahora la tarea es un Workflow duradero de Cloudflare en cinco pasos, cada uno con un presupuesto nuevo.

El resto son la razón del título de este post. Cada uno, por sí solo, basta para perder todos los autobuses, o para ocultar que los has perdido, y ninguno pone nada en rojo.

Un número en blanco tira todos los autobuses. El lector de GTFS de Valhalla convierte los números sin miramientos, y una sola coordenada vacía en shapes.txt hace que std::stod lance una excepción:

[ERROR] Couldn't find a required file for feed cuando: stod while adding item from shapes.txt
[ERROR] Couldn't find any usable GTFS feeds.

Ahí no termina la compilación. Valhalla sigue sin transporte público y construye un grafo perfectamente válido sin ningún autobús. Y nuestro shapes.txt no tenía una coordenada vacía. Más de la mitad de sus filas eran así:

guardamar-hospital,,,1

Cada arista guarda la calzada que sigue como una lista de puntos, y nuestras aristas los guardan en dos codificaciones: pares [lat, lng] y objetos {latitude, longitude}. Las dos son legítimas, las dos son habituales, y el mapa de la app lee las dos. El generador del feed solo leía los objetos y escribía los pares como nada. Lo mejor es la propia declaración de tipos del generador, cuyo comentario dice que la columna contiene pares [lat, lng]. El comentario acertaba con la mitad de las filas, y el código con la otra mitad.

Un zip también es un feed. La imagen busca los feeds en /gtfs_feeds, una ruta fija en sus scripts, y quiere cada uno descomprimido en su propio directorio. El script que subimos en marzo descomprimía el feed ahí correctamente, y luego dejaba el zip tirado al lado. Cualquier otra cosa en esa carpeta se trata como un feed más, y hace fallar la ingesta.

Un reinicio no ingiere nada. Ejecutamos Valhalla con su imagen Docker valhalla-scripted, que se configura con variables de entorno, y estas no significan lo que dicen. build_transit=True construye el transporte público solo si todavía no hay teselas de transporte público. build_tar=True construye el archivo de teselas solo si todavía no hay archivo. Y el servicio sirve ese archivo, no las teselas nuevas que tiene al lado. De los propios scripts de la imagen:

# configure_valhalla.sh: transit builds only if the directory is missing or empty
if [[ "${build_transit}" == "Force" ]] || (! [[ -d ${TRANSIT_DIR} ]] && [[ "${build_transit}" == "True" ]]) || ...

# docker-entrypoint.sh: the archive is built only if it does not already exist
if ([[ "${build_tar_local}" == "True" && ! -f $TILE_TAR ]]) || [[ "${build_tar_local}" == "Force" ]]; then

Nuestro script de sincronización terminaba con un reinicio, bajo el comentario «Reiniciar Valhalla para reconstruir con los nuevos datos de transporte público». Una vez que hay teselas de transporte público, un reinicio no reconstruye nada de eso. El feed nuevo se queda en el disco y el grafo viejo sigue respondiendo.

El arreglo obvio es una trampa. La imagen también acepta Force, que reconstruye siempre. Pero el entorno de un contenedor queda fijado al crearlo, y el nuestro está configurado para volver a levantarse solo. Créalo una vez con Force, y cada reinicio de la VM borra las teselas y las reconstruye durante unos veinte minutos, haya cambiado el feed o no. El fichero compose que subimos en marzo tenía activado un primo de ese interruptor, force_rebuild=True. Reconstruye todo el grafo de calles en cada arranque y aun así deja en paz las teselas de transporte público existentes: veinte minutos reconstruyéndolo todo salvo lo único que había cambiado.

Lo que funciona es al revés: dejar las variables en True y borrar las teselas de transporte público y el archivo antes de volver a crear el contenedor. Así, True construye justo cuando hay algo que construir. Una reconstrucción tarda de diez a veinticinco minutos con cuatro hilos, para un extracto de OpenStreetMap de unos 46 MB.

Un calendario caduca sin avisar. calendar.txt dice qué días funciona cada servicio, entre una fecha de inicio y una de fin. El nuestro cubre las salidas que hemos generado, unas seis semanas por delante. Un feed cuya fecha de fin ya pasó se compila sin problemas y no lleva a nadie a ningún sitio, sin ningún error. El feed que publicamos hoy deja de dar rutas el 13 de septiembre, salvo que antes lo sustituya uno más nuevo.

Ir a pie también es un 200. Cuando Valhalla no tiene autobuses, o ninguno que sirva, una petición de ruta en autobús no falla. Responde con una ruta a pie y HTTP 200, exactamente igual que un éxito. La función que escribí en marzo comprobaba exactamente una cosa, res.ok. Si algo la hubiera llamado, habría metido una ruta a pie en la lista de rutas en autobús, y habría parecido correcta.

Enchufarlo

Una vez arreglado el feed, la búsqueda de rutas de la app pasó a salir de Valhalla. Lo que hace el Worker con la respuesta:

  • Preguntar más de una vez. Valhalla devuelve un itinerario por petición, y la app muestra unos cuantos para elegir. Así que el Worker pregunta hasta tres veces, excluyendo cada vez las líneas que usaron las respuestas anteriores. Si aun así una respuesta vuelve igual, para.
  • Leer de vuelta nuestros propios ids. Valhalla devuelve los ids de nuestro feed envueltos en los suyos: cuando_06-2 para la línea, cuando_c-argonauto_transit_station para una parada. Quítales el envoltorio y son los ids que la app ya conoce, así que la app no necesitó ni un cambio.
  • Nunca fiarse del nombre. El nombre corto de la línea 06-2 es «06», y también lo es el de la línea que va en sentido contrario. Busca las líneas por nombre y te sale el número correcto en el sentido equivocado.
  • Mandar la hora local. Valhalla recibe la hora de salida como hora local de reloj, porque las horas de stop_times.txt son locales. Manda UTC y en agosto te salen los autobuses de hace dos horas.
  • Tratar una ruta solo a pie como falta de respuesta. Una respuesta sin ningún autobús cuenta como «no se ha encontrado nada». Además, cada línea y cada parada de una respuesta se comprueban contra la base de datos, así que unas teselas construidas a partir de un conjunto de datos más antiguo aparecen como un aviso en los logs y no como una línea sin nombre en la app.

Un ajuste en el Worker devuelve la búsqueda de rutas al grafo de la cuarta parte. Sin nueva versión de la app, sin revisión de la tienda.

Luego miramos el mapa

Con viajes reales llegando, miramos sus trazados. Una línea de autobús dibujada sobre un viaje se quedaba 843 metros antes de la parada donde te bajas. Otra daba un rodeo de 851 metros y se saltaba una parada. Las mismas líneas se dibujaban enteras en nuestra consola de administración, y esa fue la pista: la consola dibuja todas las aristas que tiene, y cualquier cosa que recorra en orden las aristas de una línea podía perder alguna.

Cuatro bugs distintos lo hacían. Cada uno era silencioso por construcción, con un continue o un filter donde debería haber habido un aviso:

  • Otra vez las dos codificaciones, esta vez en el código que dibuja el trazado de un viaje. Una arista guardada como pares aportaba cero puntos.
  • Un parser de ids que se comía el id. Las filas antiguas guardan el id de parada a secas, las nuevas un nombre de recurso completo, y una consulta cortaba el nombre después de /stations/ con substr(x, instr(x, '/stations/') + length('/stations/')). Con un id a secas, instr devuelve 0, así que el corte empezaba en el décimo carácter del id: c-argonauto se convertía en to, y c-perseo, más corto que eso, en nada. Ninguno de los dos coincide con nada.
  • Elegir una arista por el id más bajo. Varias líneas pueden ir entre las mismas dos paradas por calles distintas. La consulta cogía la primera, fuera de la línea que fuera.
  • Líneas circulares. El feed buscaba las aristas de una línea por la parada de la que salen. Una línea circular pasa dos veces por una parada, así que de ella salen dos aristas. El feed se quedaba con una y la usaba las dos veces: el trazado salía por un ramal, volvía, lo dibujaba otra vez y nunca dibujaba el otro ramal, el que tenía una parada.

Antes, ese mismo día, al rehacer la tarea, habíamos encontrado uno más. Todos los recorridos del feed tenían direction_id 0, porque la línea de código que debía distinguir los dos sentidos comparaba una línea con su propia opuesta.

El arreglo vino con dos tareas que comprueban la geometría y que se lanzan a mano después de que alguien edite la red. La que importa aquí lee de R2 el zip publicado, así que comprueba los bytes que ingiere Valhalla y no una generación nueva que podría ser distinta. Su comprobación principal señala cualquier parada a más de 120 metros del trazado dibujado para su recorrido. El umbral sale del informe del bug: en el caso bueno, las paradas quedaban como mucho a 41 metros de la línea, y las rotas se desviaban 313, 435 y 843.

Día de navegación

La lección que me llevo va de señales. Todas las comprobaciones que teníamos preguntaban si algo se ejecutaba: la tarea, la subida, el contenedor, la petición HTTP. Nada preguntaba si al otro lado salía un autobús. Siempre que el contenedor respondía, estaba sano. Solo que no tenía ningún autobús.

Lo que viene

  • Una sonda. Cada mañana, pedir a Valhalla un viaje que tenga que incluir un autobús, y fallar ruidosamente si no lo incluye. Ahora mismo, «la sincronización ha terminado» significa que ha empezado una reconstrucción, y la reconstrucción dura hasta veinticinco minutos más.
  • Salidas más tarde. Valhalla responde a «¿cuál es el mejor viaje si salgo ahora?», y la app todavía no tiene forma de pedir el siguiente.
  • Los propios datos. Las nuevas tareas nos han dejado una lista, y no es corta.
Escrito en septiembre de 2026. Este post lleva la fecha del día en que los autobuses pasaron a Valhalla, y está escrito tal como se veía entonces. Ocho semanas después:
  • El interruptor sigue encendido. Todas las rutas en autobús de la app salen de Valhalla desde aquella tarde. La búsqueda en grafo de la cuarta parte sigue en el código, a un ajuste de distancia.
  • Las salidas más tarde llegaron el 4 de septiembre. El comentario encima del código decía, desde el día en que se escribió, que «elegir una salida más tarde es una acción aparte y explícita en la app», una acción que no tenía adónde enviarse. Ahora la API acepta una hora de salida.
  • Las teselas recuerdan una línea hasta la siguiente reconstrucción. La noche anterior descubrimos que archivar una línea no la sacaba de la búsqueda de rutas en el acto. Las teselas se habían construido mientras funcionaba, y la comprobación que debía cazar las líneas que ya no tenemos dejaba pasar las archivadas. Ahora se descarta cualquier respuesta que use una.
  • La sonda sigue en la lista.