lepus 0.2.2 → 0.3.0

data/bin/web-demo

@@ -0,0 +1,592 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Serves the dashboard on a simulated broker that keeps moving, for working on
+# the UI without RabbitMQ or workers.
+#
+#   bin/web-demo                  # http://127.0.0.1:9393/
+#   PORT=4000 HOST=0.0.0.0 bin/web-demo
+#   HEAVY=1 bin/web-demo          # ~70 queues on 12 exchanges, 20 workers, deep backlogs
+#   MOUNT=/lepus bin/web-demo     # served under a sub-path, as `mount Lepus::Web => "/lepus"` does
+
+require "bundler/setup"
+require "logger"
+require "stringio"
+require "securerandom"
+require "webrick"
+require "lepus"
+require "lepus/web"
+
+module WebDemo
+  CYCLE = 180
+  HISTORY = 3600
+  VERSION_LABEL = "Lepus (#{Lepus::VERSION})"
+  RATES = %i[publish deliver ack redeliver].freeze
+
+  UNUSED_AFTER = 45
+
+  Exchange = Struct.new(:name, :type, keyword_init: true)
+
+  # A queue Lepus::Delay declares: "<queue>.delay.<ms>" for a queue delay
+  # (published through the default exchange, or by a consumer's delay!) or
+  # "<exchange>.delayed.<ms>" behind the "<exchange>.delayed" headers
+  # exchange. Each message waits ms, then goes to the target line. When
+  # nothing has used it for a while it expires, as x-expires does.
+  class DelayQueue
+    attr_reader :ms, :target, :exchange, :source, :held, :in_rate, :out_rate
+
+    def initialize(ms:, target:, exchange: nil, source: :producer, rate: 0.0, share: 0.0, window: nil)
+      @ms = ms
+      @target = target
+      @exchange = exchange
+      @source = source
+      @rate = rate
+      @share = share
+      @window = window
+      @held = 0.0
+      @in_rate = 0.0
+      @out_rate = 0.0
+      @used_at = nil
+    end
+
+    def name
+      exchange ? Lepus::Delay.exchange_queue_name_for(exchange, ms) : Lepus::Delay.queue_delay_name_for(target.name, ms)
+    end
+
+    def arguments
+      exchange ? Lepus::Delay.queue_args_for_exchange(exchange, ms) : Lepus::Delay.queue_args_for_queue(target.name, ms)
+    end
+
+    def present?(second)
+      !@used_at.nil? && (@held >= 0.5 || second - @used_at < UNUSED_AFTER)
+    end
+
+    def step(second, dt, rng, failing:)
+      wave = 1 + 0.25 * Math.sin(second / 37.0 + ms % 11) + (rng.rand - 0.5) * 0.2
+      open = @window.nil? || @window.cover?(second % CYCLE)
+      @in_rate = if !open
+        0.0
+      elsif source == :consumer
+        target.rate(:deliver) * (failing ? @share * 6 : @share) * wave
+      else
+        @rate * wave
+      end
+      released = @held * [dt * 1000.0 / ms, 1].min
+      @held = [@held + @in_rate * dt - released, 0.0].max
+      @out_rate = released / dt
+      @used_at = second if @in_rate.positive?
+      target.counters[:delayed] += @in_rate * dt if source == :consumer
+    end
+  end
+
+  # One main queue with its consumer, and the counters the simulation moves.
+  class Line
+    attr_reader :name, :exchange, :keys, :consumer, :worker, :base, :retry_ttl, :error_queue, :threads
+    attr_accessor :ready, :unacked, :retrying, :errors, :rates, :counters, :backlog_rate, :channels
+
+    def initialize(name:, exchange:, keys: [], consumer: nil, worker: nil, base: 1.0, retry_ttl: 5000, error_queue: true, threads: 2, ready: 0, idle: false, capacity: 1.15, drain: 0.4)
+      @name = name
+      @exchange = exchange
+      @keys = keys
+      @consumer = consumer
+      @worker = worker
+      @base = idle ? 0.0 : base
+      @retry_ttl = retry_ttl
+      @error_queue = error_queue
+      @threads = threads
+      @capacity = capacity
+      @drain = drain
+      @ready = ready.to_f
+      @unacked = 0
+      @retrying = 0.0
+      @errors = 0.0
+      @backlog_rate = 0.0
+      @channels = consumer ? threads : 0
+      @rates = Hash.new(0.0)
+      @counters = Hash.new(0.0)
+      @phase = name.sum % 17
+      @period = 40 + name.sum % 50
+    end
+
+    def retry?
+      retry_ttl ? true : false
+    end
+
+    def step(t, dt, rng, slow:, failing:, released: 0.0)
+      wave = 1 + 0.3 * Math.sin(t / @period.to_f + @phase) + (rng.rand - 0.5) * 0.16
+      publish = @base * wave + released
+      returning = retry? ? @retrying * [dt * 1000.0 / retry_ttl, 1].min : 0.0
+      @retrying -= returning
+      capacity = channels.zero? ? 0.0 : (@base + released) * capacity_share(slow)
+      available = @ready + (publish + returning / dt) * dt
+      deliver = [capacity * dt, available].min / dt
+      reject_share = failing ? 0.3 : 0.004
+      rejected = deliver * reject_share
+      error_share = failing ? 0.35 : 0.02
+      to_error = error_queue ? rejected * error_share : 0.0
+      to_retry = retry? ? rejected - to_error : 0.0
+      previous = @ready
+      @ready = [@ready + (publish + returning / dt - deliver) * dt, 0.0].max
+      @retrying += to_retry * dt
+      @errors += to_error * dt
+      @backlog_rate = @backlog_rate * 0.6 + ((@ready - previous) / dt) * 0.4
+      @unacked = [(deliver * 0.2).round, channels * 10].min
+      @rates = {publish: publish + returning / dt, deliver: deliver, ack: deliver - rejected, redeliver: returning / dt, retry_in: to_retry, error_in: to_error, released: released}
+      @counters[:publish] += publish * dt
+      @counters[:processed] += (deliver - rejected) * dt
+      @counters[:rejected] += to_retry * dt
+      @counters[:errored] += to_error * dt
+    end
+
+    def rate(key)
+      @rates.fetch(key, 0.0)
+    end
+
+    private
+
+    def capacity_share(slow)
+      return 0.1 if slow
+
+      @capacity + ((@ready > 0) ? @drain : 0)
+    end
+  end
+
+  # The broker and the workers reading it, advanced once a second.
+  class World
+    attr_reader :exchanges, :lines, :delays, :supervisors, :workers, :history, :started_at, :second
+
+    def initialize(heavy: false, seed: 7)
+      @rng = Random.new(seed)
+      @mutex = Mutex.new
+      @history = []
+      @exchanges = []
+      @lines = []
+      @delays = []
+      heavy ? build_heavy : build_normal
+      build_processes
+      @started_at = Time.now - HISTORY
+      HISTORY.times { |second| advance(second, 1.0, record_at: @started_at + second) }
+      @clock = HISTORY
+    end
+
+    def start
+      Thread.new do
+        loop do
+          sleep 1
+          synchronize do
+            advance(@clock, 1.0, record_at: Time.now)
+            @clock += 1
+          end
+        end
+      end
+      self
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+
+    private
+
+    def build_normal
+      add_exchange("orders", :topic)
+      add_exchange("invoices", :direct)
+      add_exchange("emails", :fanout)
+      add_exchange("webhooks", :topic)
+      add_exchange("notifications", :fanout)
+      add_exchange("audit", :headers)
+
+      add_line("orders.fulfillment", "orders", %w[order.paid], "FulfillmentConsumer", "default", 42, threads: 5)
+      add_line("orders.billing", "orders", %w[order.created order.paid order.cancelled], "BillingConsumer", "billing", 18)
+      add_line("orders.analytics", "orders", %w[order.#], "OrderAnalyticsConsumer", "default", 64, retry_ttl: nil, error_queue: false, threads: 3)
+      add_line("invoices.render", "invoices", %w[invoice.render], "InvoiceRenderConsumer", "billing", 60, ready: 40)
+      add_line("invoices.deliver", "invoices", %w[invoice.deliver], "InvoiceDeliveryConsumer", "billing", 9)
+      add_line("emails.transactional", "emails", [], "TransactionalEmailConsumer", "mailers", 30, threads: 4)
+      add_line("emails.digest", "emails", [], "DigestEmailConsumer", "mailers", 2.5, retry_ttl: 30_000)
+      add_line("webhooks.outbound", "webhooks", %w[webhook.#], "WebhookDeliveryConsumer", "webhooks", 22, threads: 6)
+      add_line("notifications.push", "notifications", [], "PushNotificationConsumer", "mailers", 15)
+      add_line("notifications.sms", "notifications", [], nil, nil, 0, idle: true)
+      delay_exchange("orders", "orders.billing", 5000, rate: 1.2)
+      delay_exchange("orders", "orders.billing", 300_000, rate: 0.4)
+      delay_queue("emails.digest", 60_000, rate: 2.0)
+      delay_queue("emails.digest", 3_600_000, rate: 0.06)
+      delay_queue("invoices.deliver", 10_000, rate: 1.5, window: 0...50)
+      delay_queue("webhooks.outbound", 30_000, source: :consumer, share: 0.03)
+      @scripted = {slow: "invoices.render", failing: "webhooks.outbound"}
+    end
+
+    DOMAINS = {
+      "orders" => %w[created paid cancelled refunded fulfillment billing analytics],
+      "invoices" => %w[render deliver remind void archive],
+      "emails" => %w[transactional digest bounce receipt welcome],
+      "webhooks" => %w[outbound retries partner audit],
+      "payments" => %w[authorize capture refund dispute payout settle],
+      "shipments" => %w[label dispatch track deliver return],
+      "reports" => %w[daily weekly monthly export],
+      "exports" => %w[csv pdf archive],
+      "search" => %w[index reindex suggest purge],
+      "inventory" => %w[reserve release restock count audit],
+      "users" => %w[signup verify login profile delete],
+      "notifications" => %w[push sms email slack teams digest inbox web mobile desktop pager voice chat badge feed alerts]
+    }.freeze
+
+    BACKLOGS = {
+      "reports.monthly" => {ready: 1_200_000, capacity: 0.97, drain: 0.0},
+      "search.reindex" => {ready: 250_000, capacity: 0.99, drain: 0.0},
+      "exports.pdf" => {ready: 4_800, capacity: 1.0, drain: 0.0}
+    }.freeze
+
+    def build_heavy
+      workers = (1..20).map { |n| "pool-#{n}" }
+      DOMAINS.each_with_index do |(domain, actions), index|
+        fanout = domain == "notifications"
+        type = index.even? ? :topic : :direct
+        add_exchange(domain, fanout ? :fanout : type)
+        actions.each_with_index do |action, position|
+          name = "#{domain}.#{action}"
+          keys = fanout ? [] : ["#{domain}.#{action}"]
+          keys << "#{domain}.#{action}.urgent" if position.zero?
+          keys << "#{domain}.all" if position == 1
+          base = (10**(@rng.rand * 3.1)).round(1)
+          consumer = "#{domain.capitalize.chomp("s")}#{action.split("_").map(&:capitalize).join}Consumer"
+          idle = (index + position) % 9 == 4
+          add_line(name, domain, keys, idle ? nil : consumer, workers[(index * 3 + position) % workers.size], base,
+            idle: idle, threads: 1 + position % 5, **BACKLOGS.fetch(name, {}))
+        end
+      end
+      delay_queue("payments.capture", 1000, rate: 40)
+      delay_queue("payments.capture", 15_000, rate: 12)
+      delay_queue("payments.capture", 120_000, rate: 6)
+      delay_exchange("payments", "payments.settle", 600_000, rate: 0.8)
+      delay_exchange("payments", "payments.payout", 86_400_000, rate: 0.02)
+      delay_queue("notifications.digest", 900_000, rate: 1.1)
+      delay_queue("users.verify", 300_000, rate: 0.3, window: 0...90)
+      delay_queue("shipments.track", 60_000, source: :consumer, share: 0.05)
+      delay_queue("webhooks.outbound", 30_000, source: :consumer, share: 0.03)
+      @scripted = {slow: "invoices.render", failing: "webhooks.outbound"}
+    end
+
+    def add_exchange(name, type)
+      @exchanges << Exchange.new(name: name, type: type.to_s)
+    end
+
+    def add_line(name, exchange, keys, consumer, worker, base, **options)
+      @lines << Line.new(name: name, exchange: exchange, keys: keys, consumer: consumer, worker: worker, base: base, **options)
+    end
+
+    def delay_queue(target, ms, **options)
+      @delays << DelayQueue.new(ms: ms, target: line(target), **options)
+    end
+
+    def delay_exchange(exchange, target, ms, **options)
+      delayed = Lepus::Delay.exchange_name_for(exchange)
+      add_exchange(delayed, :headers) unless @exchanges.any? { |candidate| candidate.name == delayed }
+      @delays << DelayQueue.new(ms: ms, target: line(target), exchange: exchange, **options)
+    end
+
+    public
+
+    def line(name)
+      @lines.find { |candidate| candidate.name == name }
+    end
+
+    def live_delays
+      @delays.select { |delay| delay.present?(@second) }
+    end
+
+    def consumer_delays(line)
+      @delays.select { |delay| delay.source == :consumer && delay.target == line }.map(&:ms)
+    end
+
+    private
+
+    def build_processes
+      names = @lines.map(&:worker).compact.uniq
+      apps = (names.size > 6) ? %w[orders-service billing-service mailer-service platform-service] : %w[orders-service mailer-service]
+      hosts = apps.each_with_index.map { |_app, index| "app-#{index + 1}.internal" }
+      @supervisors = apps.each_with_index.map do |app, index|
+        {id: SecureRandom.uuid, name: "supervisor-#{index + 1}", pid: 4100 + index * 100, hostname: hosts[index], kind: "Supervisor", application: app}
+      end
+      @workers = names.each_with_index.map do |worker, index|
+        supervisor = @supervisors[index % @supervisors.size]
+        {
+          id: SecureRandom.uuid, name: worker, pid: supervisor[:pid] + 10 + index, hostname: supervisor[:hostname], kind: "Worker",
+          supervisor_id: supervisor[:id], application: supervisor[:application], rss: 120 + @rng.rand(260), late: names.size > 6 && index == 5
+        }
+      end
+    end
+
+    def advance(second, dt, record_at:)
+      @second = second
+      phase = second % CYCLE
+      totals = Hash.new(0.0)
+      failing = ->(line) { line.name == @scripted[:failing] && phase >= 90 && phase < 130 }
+      @delays.each { |delay| delay.step(second, dt, @rng, failing: failing.call(delay.target)) }
+      released = @delays.group_by(&:target).transform_values { |list| list.sum(&:out_rate) }
+      @lines.each do |line|
+        slow = line.name == @scripted[:slow] && phase >= 20 && phase < 60
+        line.errors *= 0.3 if phase.zero?
+        line.step(second, dt, @rng, slow: slow, failing: failing.call(line), released: released.fetch(line, 0.0))
+        RATES.each { |key| totals[key] += line.rate(key) }
+      end
+      @delays.each { |delay| totals[:publish] += delay.in_rate }
+      @workers&.each { |worker| worker[:rss] = (worker[:rss] + @rng.rand(-3..3)).clamp(120, 400) }
+      @history << {at: record_at, counts: totals}
+      @history.shift while @history.size > HISTORY
+    end
+  end
+
+  # Answers like Lepus::Web::ManagementAPI, from the simulated broker.
+  class ManagementAPI
+    def initialize(world)
+      @world = world
+    end
+
+    def queues
+      @world.synchronize do
+        @world.lines.flat_map { |line| queue_rows(line) } + @world.live_delays.map { |delay| delay_row(delay) }
+      end
+    end
+
+    def queue(name)
+      queues.find { |q| q[:name] == name }
+    end
+
+    def exchanges
+      @world.synchronize do
+        @world.exchanges.map do |exchange|
+          lines = @world.lines.select { |line| line.exchange == exchange.name }
+          direct = lines.map { |line| line.rate(:publish) - line.rate(:redeliver) - line.rate(:released) }
+          out = direct.sum
+          incoming = (exchange.type == "fanout") ? (direct.max || 0) : out
+          fed = @world.delays.select { |delay| delay.exchange && Lepus::Delay.exchange_name_for(delay.exchange) == exchange.name }
+          incoming = out = fed.sum(&:in_rate) unless fed.empty?
+          released = @world.delays.select { |delay| delay.exchange == exchange.name }.sum(&:out_rate)
+          incoming += released
+          out += released
+          {
+            name: exchange.name, type: exchange.type, durable: true, auto_delete: false,
+            message_stats: {publish_in: 0, publish_in_rate: incoming.round(2), publish_out: 0, publish_out_rate: out.round(2)}
+          }
+        end
+      end
+    end
+
+    def bindings
+      @world.synchronize do
+        rows = @world.lines.flat_map do |line|
+          keys = line.keys.empty? ? [""] : line.keys
+          keys.map { |key| binding(line.exchange, line.name, key) }
+        end
+        rows + @world.live_delays.select(&:exchange).map do |delay|
+          binding(Lepus::Delay.exchange_name_for(delay.exchange), delay.name, "", "x-match" => "all", Lepus::Delay::HEADER => delay.ms)
+        end
+      end
+    end
+
+    def consumers
+      @world.synchronize do
+        @world.lines.select(&:consumer).flat_map do |line|
+          (1..line.channels).map do |n|
+            {
+              queue: line.name, consumer_tag: "#{line.consumer}-#{n}", connection_name: "#{VERSION_LABEL} #{line.worker}",
+              channel: "#{line.worker} (#{n})", prefetch_count: 10, ack_required: true, active: true
+            }
+          end
+        end
+      end
+    end
+
+    def connections
+      @world.synchronize do
+        workers = @world.workers.map do |worker|
+          connection("#{VERSION_LABEL} #{worker[:name]}", @world.lines.count { |line| line.worker == worker[:name] } * 2)
+        end
+        producers = @world.supervisors.map { |supervisor| connection("#{supervisor[:application]} publisher", 1) }
+        workers + producers + [connection("#{VERSION_LABEL} (web-aggregator)", 1)]
+      end
+    end
+
+    def overview(age: nil, increment: 10)
+      @world.synchronize do
+        history = @world.history
+        now = history.last[:counts]
+        {
+          rabbitmq_version: "4.1.2",
+          cluster_name: "rabbit@demo",
+          rates: {publish: now[:publish].round(2), deliver: now[:deliver].round(2), ack: now[:ack].round(2), redeliver: now[:redeliver].round(2)},
+          queue_totals: {
+            messages: @world.lines.sum { |line| line.ready + line.unacked }.round,
+            messages_ready: @world.lines.sum(&:ready).round,
+            messages_unacknowledged: @world.lines.sum(&:unacked)
+          },
+          object_totals: {queues: queues_count + @world.live_delays.size, exchanges: @world.exchanges.size},
+          history: age ? buckets(history.last(age), increment) : []
+        }
+      end
+    end
+
+    private
+
+    def queues_count
+      @world.lines.sum { |line| 1 + (line.retry? ? 1 : 0) + (line.error_queue ? 1 : 0) }
+    end
+
+    def buckets(rows, increment)
+      rows.each_slice(increment).map do |slice|
+        totals = RATES.map { |key| [key, (slice.sum { |row| row[:counts][key] } / slice.size).round(2)] }.to_h
+        totals.merge(t: slice.last[:at].utc.iso8601)
+      end
+    end
+
+    def queue_rows(line)
+      main_args = {}
+      main_args = {"x-dead-letter-exchange" => "", "x-dead-letter-routing-key" => "#{line.name}.retry"} if line.retry?
+      rows = [queue_row(line.name, line.ready, line.unacked, line.channels, main_args,
+        publish: line.rate(:publish), deliver: line.rate(:deliver), ack: line.rate(:ack), redeliver: line.rate(:redeliver), backlog: line.backlog_rate)]
+      if line.retry?
+        rows << queue_row("#{line.name}.retry", line.retrying, 0, 0,
+          {"x-dead-letter-exchange" => "", "x-dead-letter-routing-key" => line.name, "x-message-ttl" => line.retry_ttl},
+          publish: line.rate(:retry_in))
+      end
+      rows << queue_row("#{line.name}.error", line.errors, 0, 0, {}, publish: line.rate(:error_in)) if line.error_queue
+      rows
+    end
+
+    def delay_row(delay)
+      queue_row(delay.name, delay.held, 0, 0, delay.arguments, publish: delay.in_rate)
+    end
+
+    def queue_row(name, ready, unacked, consumers, arguments, publish: 0.0, deliver: 0.0, ack: 0.0, redeliver: 0.0, backlog: 0.0)
+      ready = ready.round
+      {
+        name: name, type: "classic", messages: ready + unacked, messages_ready: ready, messages_unacknowledged: unacked,
+        consumers: consumers, memory: 20_000 + ready * 600, state: "running", durable: true, exclusive: false, auto_delete: false,
+        arguments: arguments, idle_since: nil, consumer_utilisation: consumers.zero? ? nil : 0.9,
+        messages_rate: backlog.round(2), messages_ready_rate: backlog.round(2),
+        message_stats: {
+          publish: 0, publish_rate: publish.round(2), deliver_get: 0, deliver_get_rate: deliver.round(2),
+          ack: 0, ack_rate: ack.round(2), redeliver: 0, redeliver_rate: redeliver.round(2)
+        }
+      }
+    end
+
+    def binding(source, destination, key, arguments = {})
+      {source: source, destination: destination, destination_type: "queue", routing_key: key, arguments: arguments}
+    end
+
+    def connection(name, channels)
+      {
+        name: "10.0.0.#{name.sum % 200 + 10}:#{40_000 + name.sum} -> 10.0.0.2:5672", state: "running", user: "app", vhost: "/",
+        channels: channels, connected_at: ((@world.started_at.to_f + (name.sum % 900)) * 1000).round,
+        client_properties: {connection_name: name}
+      }
+    end
+  end
+
+  # Answers like Lepus::Web::Aggregator, with a heartbeat per simulated process.
+  class Aggregator
+    def initialize(world)
+      @world = world
+    end
+
+    def start
+    end
+
+    def stop
+    end
+
+    def running?
+      true
+    end
+
+    def all_processes
+      @world.synchronize do
+        supervisors = @world.supervisors.map { |supervisor| process(supervisor, 0, consumers: []) }
+        supervisors + @world.workers.map { |worker| worker_process(worker) }
+      end
+    end
+
+    def find(id)
+      all_processes.find { |process| process[:id] == id }
+    end
+
+    def count
+      all_processes.size
+    end
+
+    private
+
+    def worker_process(worker)
+      lines = @world.lines.select { |line| line.worker == worker[:name] && line.consumer }
+      consumers = lines.map do |line|
+        {
+          class_name: line.consumer, exchange: line.exchange, queue: line.name, route: line.keys.first,
+          retry_queue: (line.retry? ? "#{line.name}.retry" : nil), error_queue: (line.error_queue ? "#{line.name}.error" : nil),
+          threads: line.threads, processed: line.counters[:processed].round, rejected: line.counters[:rejected].round,
+          errored: line.counters[:errored].round, delayed: line.counters[:delayed].round,
+          delays: @world.consumer_delays(line).then { |delays| delays.empty? ? nil : delays }
+        }
+      end
+      process(worker, worker[:rss] * 1024 * 1024, consumers: consumers, connections: 1 + lines.size / 4, late: worker[:late])
+    end
+
+    def process(data, rss, consumers:, connections: 1, late: false)
+      age = late ? rand(150..159) : rand(0..25)
+      {
+        id: data[:id], name: data[:name], pid: data[:pid], hostname: data[:hostname], kind: data[:kind],
+        supervisor_id: data[:supervisor_id], application: data[:application],
+        last_heartbeat_at: (Time.now - age).utc.iso8601(6),
+        rss_memory: rss, connections: connections, consumers: consumers
+      }
+    end
+  end
+
+  # Just enough of a Rack handler on WEBrick, which ships with Ruby.
+  class Servlet < WEBrick::HTTPServlet::AbstractServlet
+    def initialize(server, app)
+      super(server)
+      @app = app
+    end
+
+    def service(request, response)
+      env = {
+        "REQUEST_METHOD" => request.request_method, "SCRIPT_NAME" => "", "PATH_INFO" => request.path,
+        "QUERY_STRING" => request.query_string.to_s, "SERVER_NAME" => request.host.to_s, "SERVER_PORT" => request.port.to_s,
+        "SERVER_PROTOCOL" => "HTTP/1.1", "rack.url_scheme" => "http", "rack.input" => StringIO.new(request.body.to_s),
+        "rack.errors" => $stderr
+      }
+      request.each { |name, value| env["HTTP_#{name.upcase.tr("-", "_")}"] = value }
+      status, headers, body = @app.call(env)
+      response.status = status
+      headers.each { |name, value| response[name] = value }
+      response.body = +""
+      body.each { |chunk| response.body << chunk }
+      body.close if body.respond_to?(:close)
+    end
+  end
+
+  def self.install(heavy:)
+    world = World.new(heavy: heavy)
+    Lepus::Web.aggregator = Aggregator.new(world)
+    Lepus::Web.management_api = ManagementAPI.new(world)
+    world
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  $stdout.sync = true
+  Lepus.logger = Logger.new(File::NULL)
+  heavy = ENV["HEAVY"] == "1"
+  world = WebDemo.install(heavy: heavy).start
+  mount = ENV.fetch("MOUNT", "").chomp("/")
+  app = mount.empty? ? Lepus::Web : Rack::URLMap.new(mount => Lepus::Web)
+  port = Integer(ENV.fetch("PORT", "9393"))
+  host = ENV.fetch("HOST", "127.0.0.1")
+  server = WEBrick::HTTPServer.new(Port: port, BindAddress: host, Logger: WEBrick::Log.new(File::NULL), AccessLog: [])
+  server.mount("/", WebDemo::Servlet, app)
+  trap("INT") { server.shutdown }
+  trap("TERM") { server.shutdown }
+  puts "Lepus dashboard demo#{" (heavy)" if heavy}: #{world.lines.size} queues on http://#{host}:#{port}#{mount}/"
+  server.start
+end

data/docs/brand/BRAND.md

@@ -0,0 +1,67 @@
+# Lepus brand kit
+
+## The mark
+
+A capital L drawn as a single route. The upright is the hare's ear; the foot curls back into a rounded body, and the amber dot inside it is a message in transit. One line, one stop, one message: the mark reads as "L", as a hare, and as a route carrying work.
+
+## Colours
+
+| Role  | Light background | Dark background |
+|-------|------------------|-----------------|
+| Ink   | `#1a2233`        | `#e3e9f3`       |
+| Amber | `#f2a30f`        | `#f2a30f`       |
+| Tile (app icons) | `#1a2233` | `#1a2233` |
+
+Amber is reserved for the message dot and the rule under "SAGA". Do not recolour the line in amber or put the dot in ink (except in the mono files).
+
+## Clear space and minimum size
+
+- Clear space: keep at least the height of the mark's body (the rounded loop, about one third of the mark's height) empty on every side.
+- `mark*.svg`: 48 px and up.
+- `mark-small*.svg` / `favicon.svg`: 16 to 48 px. Its line is heavier and every edge sits on the 16, 32, 48 and 64 px pixel grids, so it stays sharp at favicon sizes. Do not use it large.
+- `lockup-lepus*`: 120 px wide minimum. `lockup-lepus-saga*`: 180 px wide minimum (below that, "SAGA" gets too small; use `lockup-lepus` or the mark alone).
+
+## Which file where
+
+| Use | File |
+|-----|------|
+| README header, Lepus | `lockup-lepus-on-light.svg` + `lockup-lepus-on-dark.svg` in a `<picture>` (below) |
+| README header, Lepus saga | `lockup-lepus-saga-on-light.svg` + `lockup-lepus-saga-on-dark.svg` |
+| Web page header that follows the OS theme | `lockup-lepus.svg`, `lockup-lepus-saga.svg`, `mark.svg` (ink switches with `prefers-color-scheme`) |
+| Inline in an app that sets its own text colour | `*-mono.svg` (everything is `currentColor`) |
+| Fixed background you control | `*-on-light.svg` / `*-on-dark.svg` |
+| Browser tab | `favicon.svg` (adaptive), with `favicon.ico` (16/32/48) as fallback |
+| iOS home screen | `apple-touch-icon.png` (180, solid tile) |
+| Web manifest / PWA | `icon-512.png` (solid tile, mark inside the maskable safe zone) |
+| Legacy PNG favicons | `favicon-16.png`, `favicon-32.png` (transparent, light-background ink) |
+
+All wordmark text is outlined Overpass (SIL Open Font License), so no font is needed to render it.
+
+### README
+
+GitHub follows the viewer's GitHub theme only through `<picture>`, so use the light/dark pair rather than the adaptive file:
+
+```html
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="docs/brand/lockup-lepus-on-dark.svg">
+    <img alt="Lepus" src="docs/brand/lockup-lepus-on-light.svg" width="278">
+  </picture>
+</p>
+```
+
+For Lepus saga, swap in `lockup-lepus-saga-on-dark.svg` / `lockup-lepus-saga-on-light.svg` and `width="359"`.
+
+### HTML head
+
+```html
+<link rel="icon" href="/favicon.ico" sizes="48x48">
+<link rel="icon" href="/favicon.svg" type="image/svg+xml">
+<link rel="apple-touch-icon" href="/apple-touch-icon.png">
+```
+
+## Don'ts
+
+- Don't redraw the wordmark in live text or another typeface.
+- Don't stretch, rotate, outline or add effects to the mark.
+- Don't put the ink mark on mid-tone or busy backgrounds; use the tile or the mono file instead.

data/docs/brand/favicon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Lepus"><title>Lepus</title><style>.i{stroke:#1a2233}.f{fill:#1a2233}@media (prefers-color-scheme:dark){.i{stroke:#e3e9f3}.f{fill:#e3e9f3}}</style><path class="i" d="M12 6 V40 A16 16 0 0 0 28 56 H42 A10 10 0 0 0 42 36 H28 V18" fill="none" stroke-width="8" stroke-linecap="round" stroke-linejoin="round"/><circle cx="40" cy="46" r="5" fill="#f2a30f"/></svg>

data/docs/brand/lockup-lepus-mono.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="-6.00 -64.40 259.67 84.00" width="278" height="90" role="img" aria-label="Lepus"><title>Lepus</title><g transform="translate(-13.03 -60.26) scale(1.2414)"><path d="M14 5 V42 A14 14 0 0 0 28 56 H42 A10 10 0 0 0 42 36 H28 V15" fill="none" stroke="currentColor" stroke-width="7" stroke-linecap="round" stroke-linejoin="round"/><circle cx="40.5" cy="46" r="4" fill="currentColor"/></g><path fill="currentColor" d="M80.05 0V-44.8H89.26V-8.91H110.81V0H80.05ZM128.16 0.77Q123.38 0.77 119.92 -1.31Q116.46 -3.39 114.61 -7.24Q112.76 -11.08 112.76 -16.38Q112.76 -21.64 114.65 -25.48Q116.54 -29.31 120 -31.39Q123.45 -33.47 128.16 -33.47Q132.23 -33.47 135.52 -31.8Q138.81 -30.12 140.75 -26.68Q142.69 -23.24 142.69 -17.97Q142.69 -17.1 142.66 -15.84Q142.62 -14.57 142.45 -13.31H121.38Q121.44 -11.31 122.29 -9.82Q123.13 -8.34 124.64 -7.52Q126.14 -6.71 128.19 -6.71Q130.6 -6.71 132.3 -7.49Q134 -8.28 135.56 -10.07L140.62 -4.94Q138.41 -2.35 135.33 -0.79Q132.26 0.77 128.16 0.77ZM121.47 -20.02H134.24Q134.04 -21.93 133.27 -23.27Q132.5 -24.6 131.17 -25.3Q129.85 -26 127.96 -26Q125.38 -26 123.59 -24.46Q121.8 -22.92 121.47 -20.02ZM148.64 12.99V-32.7H157.43V-30.41Q159.85 -33.47 164.23 -33.47Q168.44 -33.47 171.47 -31.4Q174.51 -29.34 176.15 -25.5Q177.78 -21.66 177.78 -16.33Q177.78 -11.21 176.07 -7.37Q174.35 -3.53 171.28 -1.38Q168.2 0.77 164.12 0.77Q161.97 0.77 160.28 0Q158.6 -0.76 157.43 -2.25V9.04L148.64 12.99ZM162.75 -7.69Q165.73 -7.69 167.35 -9.96Q168.96 -12.24 168.96 -16.33Q168.96 -20.51 167.35 -22.77Q165.74 -25.02 162.75 -25.02Q161 -25.02 159.72 -24.46Q158.44 -23.9 157.43 -22.71V-10.11Q158 -9.03 159.47 -8.36Q160.94 -7.69 162.75 -7.69ZM195.02 0.77Q189.74 0.77 186.71 -2.57Q183.68 -5.91 183.68 -11.78V-32.7H192.47V-15.4Q192.47 -11.26 193.74 -9.48Q195.02 -7.69 197.92 -7.69Q201.03 -7.69 202.46 -9.53Q203.89 -11.37 203.89 -15.27V-32.7H212.68V0H203.89V-3.03Q202.42 -1.17 200.15 -0.2Q197.87 0.77 195.02 0.77ZM231.57 0.77Q227.63 0.77 224.02 -0.91Q220.41 -2.59 218.35 -5.4L224 -10.18Q225.63 -8.5 227.77 -7.49Q229.9 -6.48 231.85 -6.48Q234.11 -6.48 235.33 -7.2Q236.55 -7.92 236.55 -9.25Q236.55 -10.07 235.97 -10.74Q235.39 -11.4 233.84 -12.14Q232.3 -12.88 229.42 -13.93Q223.86 -15.94 221.58 -18.28Q219.31 -20.63 219.31 -24.27Q219.31 -28.39 222.64 -30.93Q225.98 -33.47 231.34 -33.47Q234.98 -33.47 238.08 -32.09Q241.17 -30.71 243.42 -28.08L237.74 -23.4Q234.87 -26.23 231.17 -26.23Q229.41 -26.23 228.31 -25.58Q227.22 -24.94 227.22 -23.91Q227.22 -22.87 228.53 -22.03Q229.85 -21.2 233.5 -20.06Q237.33 -18.91 239.75 -17.4Q242.17 -15.9 243.31 -13.9Q244.44 -11.9 244.44 -9.28Q244.44 -4.58 241.01 -1.9Q237.57 0.77 231.57 0.77Z"/></svg>