Génération de code à la compilation
spin run gen (bin/gen.rb) exécute le DSL create_table de db/schema.rb et le DSL Routes.draw de config/routes.rb pour obtenir les données des tables et des routes. Il fait séparément un balayage lexical (des regex, pas un parseur — Spinel n’en expose aucun à l’exécution) de app/controllers/**/*.rb et app/models/**/*.rb à la recherche des affectations @ivar =, des noms before_action/after_action/rescue_from ... with:, des lignes helper_method, layout et rate_limit, des include de concerns et des def sans argument. Il met une empreinte sur les fichiers de app/assets/, app/javascript/ et vendor/javascript/ lit config/importmap.rb comme du texte, et lit les dictionnaires de config/locales/ avec un lecteur YAML à lui.
À partir de cela, il écrit du Ruby simple et lisible sous gen/ :
gen/models/<name>.rb: accesseurs, conversions, finders, associations déduites des clés étrangères ;gen/routes.rb: la table des routes, le dispatcher, les helpers*_path/*_url;gen/controllers.rb:view_assigns,run_callback, la table dehelper_methodetcontroller_layoutpar contrôleur ;gen/concerns.rbetgen/concerns/**: les blocsincludeddes concerns insérés dans chaque classe qui les inclut, et les modules des concerns avec ces blocs vidés (Concerns) ;gen/assets.rb: les chemins des assets avec empreinte et l’import map (Assets), avec les fichiers à empreinte danspublic/assets/;gen/locales.rb: les dictionnaires de l’application en deux Hash, que litI18n.t(Internationalisation) ;gen/migrations.rb;gen/views.rb: la table des vues intégrées, vide sauf lors d’une compilation pour le déploiement ;gen/app.rb: le manifeste desrequire_relative;gen/tests.rbetgen/test/**: tous les tests detest/en un seul programme, chaque classe de test réécrite en méthodes, etgen/test/data.rb, les tables et les fixtures (Tester une application).
gen/ est versionné, pas ignoré par git : spin build et spin test n’ont pas de hook pour générer d’abord, donc la sortie versionnée doit déjà être ce qui compile. La CI relance spin run gen et échoue s’il y a un diff : du code généré périmé ne peut donc pas être fusionné.
Sous-systèmes
Spinel compile chaque méthode de chaque fichier qu’un programme requiert, appelée ou non, et son analyse du programme entier représente l’essentiel de chaque build. Les parties du framework qu’une application peut ne pas utiliser sont donc séparées, et bin/<app>.rb nomme celles qu’elle utilise, comme le config/application.rb de Rails liste les railties :
| Ligne | Charge |
|---|---|
require "cybertrain/core" |
HTTP, le routage, les contrôleurs, les modèles, les vues et les helpers (dont turbo_frame_tag, dom_id, render turbo_stream: et format.turbo_stream), les assets, les sessions, CSRF, CSP, la console, db et migrate |
require "cybertrain/jobs" |
Job et les classes de jobs, Scheduler (every, cron), le rôle worker, la commande jobs et la page des jobs |
require "cybertrain/streams" |
Stream.broadcast_*, le point d’accès des flux (SSE et WebSocket), Controller#turbo_stream, les helpers turbo_stream_from, turbo_stream, signed_stream_name et stream_source_path |
require "cybertrain/feeds" |
Background, le rôle feeds et son contrôle de santé ; require "cybertrain/websocket" (WebSocket.subscribe) le charge |
require "cybertrain/mailer" |
Mailer.deliver |
require "cybertrain/mailer/later" |
Mailer.deliver_later ; charge le mailer et les jobs |
require "cybertrain/cache" |
Cache |
require "cybertrain/rate_limit" |
rate_limit dans les contrôleurs ; charge le cache |
require "cybertrain/error_reporter/sentry" |
l’envoyeur Sentry : CYBERTRAIN_SENTRY_DSN envoie chaque rapport d’erreur à Sentry ou GlitchTip (Signalement des erreurs) ; charge HttpClient et TLS. Dans bin/<app>.rb seulement |
require "cybertrain" |
tout ce qui précède |
Chaque ligne se place après require "cybertrain/core" (cybertrain/jobs et cybertrain/feeds chargent le cœur eux-mêmes, les autres non), et leur ordre n’a pas d’importance : le framework démarre et arrête les sous-systèmes dans un ordre fixe qui lui est propre. Sur une application générée par scaffold, le cœur seul compile 2 205 méthodes au lieu de 2 767 et s’analyse en 38 s au lieu de 52 s ; un build complet prend 83 s au lieu de 108 s, et une modification de contrôleur environ 47 s au lieu de 65 s (docs/performance-next.md).
cybertrain new écrit require "cybertrain/core" dans bin/<app>.rb et bin/db.rb (qui charge config/app.rb et a donc besoin des mêmes lignes). cybertrain generate job ajoute require "cybertrain/jobs" aux deux, et generate authentication les quatre que son code utilise (cybertrain/jobs, cybertrain/mailer, cybertrain/mailer/later et cybertrain/rate_limit : la page des jobs, les courriels envoyés avec deliver_later, la connexion à débit limité) ; les autres lignes sont à ajouter vous-même. Une application écrite avant la séparation contient require "cybertrain", qui charge toujours tout : elle se construit et se comporte comme avant, et c’est en remplaçant cette ligne par le cœur et les lignes qu’elle utilise qu’elle se construit plus vite.
Une ligne manquante est détectée avant que l’application ne tourne :
- Du code Ruby qui nomme un sous-système manquant (
ReportJob.perform_later,Cybertrain::Stream.broadcast_append_to,Cybertrain::Mailer.deliver,rate_limit to:) ne compile pas ; l’erreur nomme la constante ou la méthode, et le tableau ci-dessus nomme sa ligne. - Une vue qui appelle un helper d’un sous-système arrête
spin run gen(etspin run gen -- --check) avec le code de sortie 1 :app/views/articles/show.html.erb:3: turbo_stream_from needs require "cybertrain/streams" in bin/blog.rb. Un template rendu malgré tout lèveundefined helper 'turbo_stream_from'. ./<app> worker,./<app> jobset./<app> feedsaffichent par exemplethe worker role needs require "cybertrain/jobs" in bin/<app>.rbet sortent avec 1./upne rend compte que de ce qui est chargé : pas de worker figé sans les jobs, pas de flux figé sans les feeds.- Un DSN défini sans la ligne de l’envoyeur Sentry fait refuser le démarrage :
error: CYBERTRAIN_SENTRY_DSN is set, but this program does not link the Sentry sender: add require "cybertrain/error_reporter/sentry" to bin/<app>.rb. Le rapporteur d’erreurs lui-même, ses abonnés et les identifiants de requête du journal sont dans le cœur.
gen lit bin/<app>.rb comme du texte et n’y voit que les lignes littérales require "cybertrain" et require "cybertrain/..." : déplacez-les dans un fichier que bin/<app>.rb charge par require_relative, et gen refuse un helper qui aurait fonctionné. Gardez-les dans bin/<app>.rb.
Sans les jobs, le cache purge lui-même ses lignes expirées : la première écriture d’un processus, puis la première après chaque cache_prune_interval, en supprime jusqu’à mille. Avec les jobs, c’est la tâche planifiée "cybertrain cache prune", comme avant (Le cache).
Deux cas ne sont pas détectés par gen : une ligne jobs_page dans config/routes.rb sans cybertrain/jobs est une erreur de compilation du contrôleur généré plutôt que le message de gen, et un job dont le retry_on ou le discard_on nomme une erreur de Cybertrain::Mailer fait requérir cybertrain/mailer par le gen/app.rb généré lui-même.
Les tests ne sont pas réduits par ces lignes : le programme que compile cybertrain test (gen/tests.rb) requiert cybertrain, tous les sous-systèmes, quoi que requière bin/<app>.rb, et l’envoyeur Sentry avec eux. Ainsi perform_enqueued_jobs, assert_emails, assert_broadcasts et Test::SentryReceiver fonctionnent dans toute application, une application sur cybertrain/core compile ses tests avec tous les sous-systèmes, et du code qui nomme un sous-système sans sa ligne passe ses tests et s'arrête à spin build (Tester une application).
Les vues sont interprétées
Les fichiers app/views/**/*.html.erb ressemblent à de l’ERB de Rails, mais sont analysés en un AST au moment de la requête, puis parcourus par un interpréteur qui parcourt l’arbre. Spinel n’a pas d’eval, il s’agit donc d’une grammaire fermée (littéraux, lectures de @ivar/variables locales, appels via des tables de dispatch fixes par type, if/unless, each/each_with_index/un bloc de helper), pas de vrai Ruby. La grammaire complète, les helpers et les lacunes se trouvent dans la référence du langage de templates.
L’origine du source dépend du mode :
- En développement (et en test), le moteur lit
app/views/depuis le disque, et en développement il réanalyse un template quand celui-ci change, donc modifier une vue ne demande pas de recompilation. cybertrain buildlanceSPIN_DEBUG=1 spin run gen -- --embed-views, qui écrit le source de chaque template dansgen/views.rbsous forme de table de chaînes pour ce seulspin build, puis relanceSPIN_DEBUG=1 spin run genpour remettre la table vide versionnée.- Le binaire de production ne rend que cette table (en analysant chaque template une seule fois) et refuse de démarrer quand elle est vide (
error: views are not embedded in this binary).
Le serveur HTTP
Cybertrain::Server est un serveur HTTP/1.1 en Ruby pur : TCPServer#accept plus un green thread Spinel par connexion (ordonnancement M:N, pas de GVL), Request/Response typés, pas de couche Rack. TLS/HTTP/2 sont laissés à un reverse proxy. SPINEL_WORKERS vaut 1 par défaut — les spikes ont montré que c’est plus rapide et sans blocage pour cette charge limitée par les E/S à 100 connexions simultanées.
Le serveur appelle un HttpHandler (call(request) -> Response) ; ContextHandler le relie à la pile de middlewares, de sorte que la couche HTTP (cybertrain/http/, plus Params et Logger) ne dépend pas du reste du framework. script/check-http-layer l’impose dans la CI.
SQLite via FFI
Les modèles parlent à SQLite directement via ffi_func/ffi_lib de Spinel — pas d’extension C, pas de gem. Chaque requête est paramétrée, jamais interpolée. C’est le seul adaptateur aujourd’hui (PostgreSQL via la FFI de libpq est noté comme travail futur possible).
Un pool (SizedQueue, 4 connexions par défaut) distribue des connexions avec :
- WAL ;
- un délai d’attente sur verrou d’environ cinq secondes, attendu dans un
sleepde green thread (100 µs d’abord, puis jusqu’à 1 ms) pour que la connexion qui tient le verrou continue de tourner même avec un seul worker ; un script de schéma attend dans SQLite (dont lebusy_timeoutdort une milliseconde ou plus) ; - jusqu’à 64 requêtes préparées en cache ;
- les clés étrangères activées.
Comment une transaction emprunte l’une de ces connexions, et ce qui s’exécute dessus : Transactions.
La boucle de développement
cybertrain server en development (le CYBERTRAIN_ENV par défaut, sauf dans un binaire issu de cybertrain build) est un superviseur. Il tourne sous CRuby, le Ruby qui exécute la commande cybertrain, garde lui-même la socket d’écoute et y fait tourner un seul processus enfant à la fois : l’application sous CRuby juste après un changement, puis le binaire compilé dès que Spinel l’a construit en arrière-plan. Une modification Ruby reçoit tout de suite la réponse de l’aperçu CRuby (en moins d’une seconde sur examples/blog), et le programme compilé reprend le port sans que vous ayez rien à faire.
Au démarrage, le superviseur lance gen sous CRuby (ruby bin/gen.rb, qui écrit le même gen/ que spin run gen), démarre l’application sous CRuby (ruby -r cybertrain/preview bin/NAME.rb) et lance la compilation. Les deux tournent avec le ruby du PATH, celui dont cybertrain doctor vérifie qu’il charge fiddle, qui peut être un autre Ruby que celui qui exécute la commande cybertrain. L’aperçu fournit au framework son FFI (SQLite, zlib) par une couche au-dessus de fiddle, la bibliothèque de Ruby, qui compile une seule fois dans tmp/cybertrain-dev/ffi/ le même C que celui du binaire. La première compilation est spin build NAME : une application qui n’a pas changé depuis la construction de son binaire ne compile rien, et le binaire répond en moins d’une seconde. Une première compilation sur un binaire plus ancien qu’un fichier Ruby, et toutes les suivantes, sont spin build NAME -- --incremental : la compilation incrémentale de Spinel, qui ne recompile que les unités C touchées par la modification. Une version de Spinel sans --incremental rejette l’option, et la compilation se fait alors sans elle. La sortie va dans tmp/rebuild.log.
Le superviseur surveille app/**/*.rb, config/**/*.rb, db/schema.rb, gen/**/*.rb et les racines des assets (app/assets/**, app/javascript/**, vendor/javascript/**) dix fois par seconde. Les vues sont exclues (les deux environnements d’exécution les relisent sur le disque), tout comme gen/views.rb, vide en développement. Un changement annule la compilation en cours, lance gen sous CRuby, remplace l’enfant par un nouvel enfant CRuby et lance une nouvelle compilation. Quand une compilation réussit et que rien n’a changé entre-temps, le superviseur arrête l’enfant CRuby et démarre build/bin/NAME sur la même socket : d’abord l’arrêt, puis le démarrage, la socket restant ouverte entre les deux, si bien qu’une requête arrivée pendant le changement attend un instant puis reçoit sa réponse. Aucune n’est refusée.
Chaque réponse de l’application porte X-Cybertrain-Runtime: cruby ou spinel, et chaque page HTML une ligne discrète dans son coin inférieur droit :
CRuby preview · Spinel building…: CRuby a rendu la page pendant la compilation.Spinel ready — reload: le binaire compilé répond désormais ; rechargez pour voir sa page.CRuby preview · Spinel build failed: CRuby continue de répondre, et la page affiche la sortie du compilateur en bannière.CRuby preview · Spinel binary failed: le binaire n’a pas démarré, ou s’est arrêté ; CRuby répond de nouveau, la bannière montre ce que le binaire a signalé, et le changement suivant le recompile et l’essaie de nouveau.Spinel: le binaire compilé a rendu la page.Source changed — reload: un fichier a changé après le rendu de la page.CRuby preview: CRuby a rendu la page et aucun des cas ci-dessus ne s’applique.
La ligne se tient à jour d’elle-même ; les pages de l’application ne se rechargent jamais toutes seules, si bien qu’un formulaire en cours de saisie n’est pas perdu. Quand gen échoue, ou que l’application ne peut pas démarrer sous CRuby (une SyntaxError, par exemple), le superviseur répond lui-même à chaque requête par une page 503 qui montre l’erreur et ce qu’il attend ; cette page, celle du superviseur lui-même, se recharge toute seule toutes les 2 s jusqu’à ce qu’un enfant puisse répondre, et l’enregistrement qui corrige l’erreur ramène l’application. Tant que cybertrain build détient tmp/cybertrain-build.lock, rien n’est régénéré ni redémarré ; le serveur rattrape son retard une fois le verrou levé. Le superviseur range ses fichiers dans tmp/cybertrain-dev/ ; un seul tourne par application, et Ctrl-C arrête la compilation, l’enfant et le serveur.
Ce que l’aperçu ne montre pas :
- Si le code compile. La compilation en arrière-plan le dit quand elle se termine.
- Les différences d’exécution consignées dans spikes/NOTES.md (la hiérarchie des exceptions, l’encodage des String sur les sockets,
Float#roundsur un Float restreint, et le reste). Elles apparaissent dès que le binaire répond. - Le temps et la concurrence : CRuby a un GVL et des threads du système, et
SPINEL_WORKERSn’a aucun sens pour lui.
Le travail en arrière-plan (les jobs, le planificateur, le poller des flux, les flux WebSocket) tourne dans l’enfant qui répond, si bien qu’une modification le redémarre deux fois, sous CRuby puis dans le binaire, et que les clients Server-Sent Events et WebSocket se reconnectent deux fois. Une page qui fonctionne dans l’aperçu n’est terminée qu’une fois que le binaire la sert aussi, et seuls les tests compilés (spin test) comptent.
cybertrain server --spinel lance à la place la boucle compilée, comme le font spin run NAME tapé directement et la CLI native que construit spin install : SPIN_DEBUG=1 spin run gen ; spin build NAME -- --incremental si un fichier Ruby est plus récent que build/bin/NAME ; puis spin run NAME. Le binaire surveille lui-même les mêmes fichiers toutes les demi-secondes, lance SPIN_DEBUG=1 spin run gen && spin build NAME -- --incremental en arrière-plan à chaque changement et, en cas de succès, arrête l’écoute, laisse se terminer les requêtes ouvertes et fait execv du nouveau binaire sur le même port et le même PID ; une compilation échouée continue de servir l’ancien binaire et affiche la sortie du compilateur en bannière sur ses réponses HTML (pas sur un téléchargement, Content-Disposition: attachment, ni sur un corps que l’application a encodé, Content-Encoding), et les recompilations sont suspendues tant que cybertrain build détient son verrou. La CLI et cette boucle compilent gen, et la CLI bin/db.rb, dans le mode debug de spin (SPIN_DEBUG=1, -O0) : ils ne tournent que quelques millisecondes, et gen se compile en une fraction du temps que prend -O2 ; l’application est toujours compilée en mode release. Quand l’aperçu ne peut pas tourner, cybertrain server affiche une ligne commençant par preview unavailable: et lance la boucle compilée. C’est le cas quand CYBERTRAIN_ENV désigne un autre environnement que development, quand le framework de l’application est plus ancien que l’aperçu (il n’a pas cybertrain/preview.rb ou cybertrain/dev/supervision.rb), quand il n’y a pas de ruby dans le PATH, ou quand ce ruby ne peut pas être lancé, ne répond pas en 10 s ou ne peut pas charger fiddle (cybertrain doctor le vérifie). Rien de tout cela n’est chargé en production.
Différences avec Rails
| Rails | CyberTrain |
|---|---|
rails console, rails dbconsole | ./<app> console évalue le langage d’expressions des templates sur les modèles (Spinel n’a pas d’eval, donc pas de Ruby) ; ./<app> dbconsole ouvre sqlite3 (La console) |
config/application.rb requiert les railties que l’application utilise | bin/<app>.rb et bin/db.rb requièrent cybertrain/core et les sous-systèmes que l’application utilise ; require "cybertrain" les charge tous |
rails runner, lib/tasks/*.rake | Cybertrain::Main.command("name", "description") { |argv| ...; 0 } dans bin/<app>.rb : ./<app> name ARGS la lance avec la base de données connectée |
| Modifiez le code, l’application en cours d’exécution le prend en compte | Les modifications Ruby apparaissent tout de suite grâce à un aperçu CRuby ; le binaire compilé reprend le port quand sa compilation se termine (cybertrain server) |
| Modifiez une vue, aucun rechargement nécessaire | Pareil — en développement, les vues sont analysées depuis le disque à chaque requête |
def new | def new_action (new masquerait Klass.new(ctx)) |
before_action { do_thing } (self implicite) | before_action { |c| c.do_thing } — pas d’instance_exec sur un bloc stocké, donc les callbacks reçoivent explicitement le contrôleur/l’enregistrement |
resources :posts do resources :comments end | resources :posts do |posts| posts.resources :comments end — les blocs imbriqués reçoivent le mapper explicitement |
| ERB est compilé en méthode ; n’importe quel objet, n’importe quelle méthode | Interprété selon une grammaire/table de dispatch fixe (Langage de templates) |
| La session contient n’importe quel objet sérialisé (marshal) | Valeurs de session de type String uniquement, dans un cookie chiffré en AES-256-GCM, comme le cookie store de Rails (Cookies et session) |
| De nombreux adaptateurs de base de données | SQLite uniquement, via FFI |
Article.transaction { ... } renvoie la valeur du bloc ; raise ActiveRecord::Rollback ; savepoints avec requires_new: true | Article.transaction { |c| ... } passe la connexion au bloc et renvoie nil ; on en sort en levant une exception ; les appels imbriqués rejoignent la transaction externe, pas de savepoints (Transactions) |
has_many :through, enums, STI, associations polymorphes | Non implémenté ; has_many, has_one et belongs_to viennent des clés étrangères ou de déclarations d’une ligne, avec dependent:, counter_cache: et un niveau d’includes (Associations) |
pluck(:a), maximum(:a), group(:a).sum(:b), upsert, update_counters, where(created_at: t1..t2) | Des variantes typées, car une méthode Spinel a un seul type de retour : pluck_int et ses semblables, maximum_int, sum_float_by, upsert, increment(:col, by: n) ; un intervalle de Time s’écrit where_between (Requêtes au-delà de where) |
N’importe quel nom de colonne ; une association peut masquer errors | Des identifiants ASCII uniquement ; une colonne nommée comme une méthode du framework ou un mot-clé Ruby est générée sous <column>_column, une association qui entre en conflit sous un nom de repli (Noms de colonnes) |
namespace, scope, formats et respond_to | Pareil (Routage, Formats) ; on répond en JSON avec render json: (pas de templates jbuilder) |
constraints, mount, segments glob | Non implémenté |
ActiveSupport::Concern inclus à l’exécution | Concerns dans app/controllers/concerns et app/models/concerns, développés par spin run gen dans les classes qui les incluent ; un include nomme un concern, et une méthode de class_methods ne peut pas porter le nom d’une méthode d’instance (Concerns) |
rescue StandardError attrape un JSON.parse qui échoue | Sous Spinel, JSON::ParserError n’est pas une StandardError : le code de l’application doit faire rescue JSON::ParserError, StandardError. Le serveur l’attrape en dernier recours et répond 500 |
skip_forgery_protection dans un contrôleur d’API | Le CSRF s’exécute avant le routage, donc une API est exemptée par chemin, c.csrf_exempt_prefixes = ["/api/"], et authentifie elle-même ses appelants (Configuration) |
| Rack laisse un corps de requête gzip tel quel | Un corps Content-Encoding: gzip est request.decoded_body, décompressé sous un plafond de 10 Mio ; un corps corrompu ou trop gros donne une 400 ; request.body reste tel qu’envoyé (Chaînes de requête et corps) |
order("lower(title)"), order("posts.title"), order(params[:sort]) | order n’accepte que des listes column [ASC|DESC] ; les données de la requête passent par une liste blanche, le SQL brut par order_sql (Tri). Des paramètres mal formés ou trop imbriqués donnent une 400 (Chaînes de requête et corps) |
| Backtrace complète lors d’une exception | Classe, message, ligne de requête, nom/ligne du template — Spinel n’expose pas de backtraces |
Rack, ses middlewares, et n’importe quelle gem d’un Gemfile | Pas de compatibilité Rack ; un petit ensemble fixe de middlewares ; le spin-index propre à Spinel, limité à ce qui compile avec son sous-ensemble de Ruby |
| minitest / RSpec | Des classes de test à la Rails (ActiveSupport::TestCase, ActionDispatch::IntegrationTest, ViewComponent::TestCase) et des fixtures, que spin run gen réécrit en un seul programme que cybertrain test compile et exécute ; les runners fondés sur la réflexion ne peuvent pas fonctionner avec une compilation AOT (Tester une application) |
bin/rails generate authentication, has_secure_password + bcrypt | cybertrain generate authentication écrit la même structure plus une page d’inscription ; les mots de passe utilisent PBKDF2-HMAC-SHA256 (bcrypt demanderait une bibliothèque C ; le String#crypt de macOS n’a pas bcrypt) ; la réinitialisation du mot de passe, la confirmation, le verrouillage et « rester connecté » sont générés aussi, comme les ajouterait Devise (Authentification) |
Active Storage, has_one_attached :cover | cybertrain generate attachment écrit cinq colonnes cover_* et les méthodes de modèle ; les fichiers résident sur le disque local sous storage/uploads/ et sont servis par send_blob ; un fichier par champ, ni variantes ni envois directs (Ajouter une image de couverture) |
skip_before_action :x | Pareil, pour les callbacks before nommés (un callback sous forme de bloc n’a pas de nom à sauter) ; pas de skip_after_action |
resource :session | Les mêmes six routes vers SessionsController ; pas d’imbrication en dessous |
get "/x" puis post "/x" | Les deux sont acceptés : le nom déduit de la seconde route est déjà pris, elle reste donc sans nom, comme dans Rails ; un as: en double reste une erreur |
Time.zone = "Asia/Tokyo", time.in_time_zone, les données de fuseaux fournies avec ActiveSupport | Cybertrain::TimeZone.find("Asia/Tokyo") lit les fichiers TZif du système (/usr/share/zoneinfo, ou TZDIR) et convertit des secondes epoch Integer (utc_offset_at, utc_to_local, local_to_utc) ; c.time_zone fixe Time.zone pour toute l’application, in_time_zone renvoie une petite valeur avec les champs muraux, et un Time reste un instant UTC (pas de TimeWithZone, time.hour est en UTC) (Fuseaux horaires) |
Net::HTTP, Faraday | Cybertrain::HttpClient pour les webhooks et les API : chaque attente est bornée, les destinations non publiques sont refusées par défaut, redirections seulement sur demande, réponses en flux et gzip, un parseur de Server-Sent Events, pas de keep-alive (voir HTTP sortant) ; le Net::HTTP de Spinel bloque tout le serveur quand un pair ne répond plus |
Action Mailer (deliver_later, classes de mailer, vues) | Cybertrain::Mailer.deliver(to:, subject:, body:, html:) envoie du texte brut, ou du multipart/alternative avec une partie HTML rendue depuis un partiel (Views.render_mail), en SMTP (STARTTLS, TLS implicite ou en clair vers le loopback ; AUTH PLAIN ; chaque attente bornée) ; Mailer.deliver_later l’envoie depuis un job intégré ; un mailer est un module de app/mailers dont les méthodes renvoient un Cybertrain::MailMessage (deliver_later, deliver_now), comme le PasswordsMailer généré ; pas de pièces jointes (voir Envoyer des e-mails) |
Active Job, perform_later, solid_queue, tâches récurrentes, Mission Control | Des classes de job dans app/jobs (< Cybertrain::Job::Base, perform(args) avec un Hash de valeurs JSON, perform_later, retry_on, discard_on, limits_concurrency avec une clé), Job.handle(kind) comme forme courte ; Scheduler.every et Scheduler.cron avec un fuseau horaire et un calendrier conservé dans la base ; une page des jobs (jobs_page dans les routes) et ./<app> jobs ; job_threads threads par processus, dans le serveur ou dans des processus ./<app> worker, livrés au moins une fois (Tâches de fond) |
Rails.cache.fetch(key, expires_in:, race_condition_ttl:) | Cybertrain::Cache.fetch dans la base SQLite de l’application, avec les mêmes options ; les valeurs sont des Strings, avec fetch_hash, fetch_array et fetch_int pour le reste ; pas de stockage en mémoire ni Redis (Le cache) |
| Client ActionCable, faye-websocket, websocket-client-simple | Cybertrain::WebSocket.subscribe(name, url) garde un flux connecté tant que le serveur tourne (reconnexions, pings, détection de silence) ; WebSocket::Client pour une connexion synchrone unique ; sortant uniquement (Consommer des flux WebSocket) |
config.filter_parameters += [:passw, /\Apin\z/, ->(k, v) { ... }] | config.filter_parameters est un Array de String comparées par sous-chaîne, sans tenir compte de la casse (ni Regexp ni lambdas) ; il s’applique au journal des requêtes et à la page d’erreur de développement (Paramètres filtrés) |
get "up" => "rails/health#show" (une route vers un contrôleur) | GET /up est intégré et reçoit sa réponse avant les fichiers statiques, la session et le routeur, donc aucun before_action ne s’exécute ; il interroge la base de données, le worker et les flux WebSocket, 200 ok ou 503 (Exploitation) |
Tâches bin/rails db:... pour les sauvegardes (aucune intégrée) | ./<app> db backup PATH / db backup DIR/ --keep N (VACUUM INTO, mode 0600, renommé à sa place) et ./<app> db vacuum |
Action Cable, turbo_stream_from, broadcast_append_to | Les mêmes noms de helpers sur des flux signés, livrés en Server-Sent Events ou en WebSocket depuis une seule table SQLite ; pas de classes de canaux (Temps réel) |
| Propshaft, importmap-rails | La même organisation (app/assets, app/javascript, vendor/javascript, config/importmap.rb), avec empreinte par spin run gen dans public/assets/ ; pas de bin/importmap pin, Turbo non fourni (Assets) |
L’i18n de Rails, les dictionnaires de rails-i18n, I18n.t, t(".title") | La même API et les mêmes clés, l’anglais et le japonais fournis ; config/locales/*.yml compilés dans le programme par spin run gen depuis un sous-ensemble de YAML (sans ancres, alias ni tags), les listes par I18n.translate_list (Internationalisation) |
Liste non exhaustive : docs/design.md §8 (« What was deliberately left out ») en est l’inventaire plus complet.