hibira-rails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec8dd25bdad390a25709965fcd822ac5882f32a09ba94ae218a61f0f3bf88463
-  data.tar.gz: 0f75219446b55e2a1385861a14e69bc33a7f77eefc6642099ba33f9a38326345
+  metadata.gz: 97801ac1dab195ec5c073b1da8db5dd483529a5ea1db1a00da08de5630610ec1
+  data.tar.gz: fa07c470a004a5340caa5fd4222ed959aa379e2c196ef5cd98f10e2448bb109e
 SHA512:
-  metadata.gz: 90e64f04f5b36d52f038dce3c950730b3b85a182981969dd41764bb9626f4e9f03dc2d1f6190959175d294dc4e9c1c7fd05cbe38b13ea63a3a11800da49ef89d
-  data.tar.gz: 0743615164b04d789f48c40eac56507c92a8462bdc212f9d2638698f916833ee25083527858103b007b4ec5f6faf8dae85fcd9bc9dc370e710d0ab5b25bc9b9b
+  metadata.gz: e096f8e71fede42bd5eb05d7225470400ea4862b1fa02a73ac05974d8e9b6033495ef819fd31b999c726c89b606ce6cf6437e6520958188ae68287dc61d174ce
+  data.tar.gz: 13073b62ab4a928572f5525606e491005202ad5c2136baddb79678df359c4a08bb3716500d702b28d64172ebfbc4ae7baa2594501f4bfe0e1d4926500f48d896

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.0
+
+- Waiting rooms: `waiting_room "presale", only: :show` in controllers and
+  `Hibira::WaitingRoom::Middleware` for path prefixes send visitors without a
+  pass to the Hibira queue and let them in with a signed pass kept in an
+  HttpOnly cookie (`hibira_pass` in the controller).
+  `Hibira::WaitingRoom.verify_pass` checks a pass anywhere.
+
+## 0.1.1
+
+- README: cover image and screenshots.
+
 ## 0.1.0
 
 - Turbo Streams over Hibira: every Turbo broadcast (`broadcasts_to`,

data/README.md

@@ -1,5 +1,7 @@
 # hibira-rails
 
+![hibira-rails](.github/cover.jpg)
+
 [![ci](https://github.com/hibira-io/rails/actions/workflows/ci.yml/badge.svg)](https://github.com/hibira-io/rails/actions/workflows/ci.yml)
 
 Hotwire Turbo Streams over [Hibira](https://hibira.io), with no Action Cable
@@ -44,6 +46,11 @@ hibira:
   secret: your-app-secret
 ```
 
+The secret is shown only once, when you create the app; the app ID and key
+stay under Overview → Credentials. On the Free plan, allowed origins can't be
+`*`: add every origin your pages load from (`http://localhost:3000` while
+developing, plus your production domain), or browsers are refused.
+
 Then check them:
 
 ```sh
@@ -190,6 +197,40 @@ Hibira.push.publish_to_users(
 web, Android and iOS SDKs. It answers only for the signed-in user
 (`current_user` or `Current.user`; change it with `config.push_user_id`).
 
+## Waiting room
+
+Put a [Hibira waiting room](https://github.com/hibira-io/waiting-room) in front
+of a ticket drop or launch page. Visitors without a pass are sent to the hosted
+queue page; when it's their turn they come back with a signed pass, which is
+checked and kept in an HttpOnly cookie.
+
+```ruby
+class DropsController < ApplicationController
+  waiting_room "presale", only: :show
+
+  def show
+    @number = hibira_pass.number # also ticket_id, expires_at
+  end
+end
+```
+
+Or protect path prefixes in any Rack app:
+
+```ruby
+# config/application.rb
+config.middleware.use Hibira::WaitingRoom::Middleware, "/drop" => "presale"
+```
+
+Non-GET requests without a pass get a `403`. Create the room (rate, start
+time, `return_urls`) with the
+[waiting rooms API](https://github.com/hibira-io/pusher-server/blob/master/docs/waiting-rooms.md).
+A pass is valid for 30 minutes by default and works in any browser; if each
+queue number may check out once, record `hibira_pass.ticket_id` and refuse a
+repeat. `Hibira::WaitingRoom.verify_pass(token, room: "presale")` checks a pass
+anywhere else.
+
+中文摘要：在搶票或限量開賣的 controller 加上 `waiting_room "presale"`（或用 Rack middleware 保護路徑），沒有 pass 的訪客會被導到 Hibira 託管的排隊頁，輪到時帶著簽名 pass 回來並存成 HttpOnly cookie。
+
 ## Settings
 
 | Setting | Environment | Default |

data/lib/hibira/engine.rb

@@ -26,6 +26,12 @@ module Hibira
       ActiveSupport.on_load(:action_view) do
         include Hibira::StreamsHelper
       end
+      ActiveSupport.on_load(:action_controller_base) do
+        include Hibira::WaitingRoom::Controller
+      end
+      ActiveSupport.on_load(:action_controller_api) do
+        include Hibira::WaitingRoom::Controller
+      end
     end
 
     # The Hibira routes are drawn straight into the app's routes (like Active

data/lib/hibira/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hibira
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/hibira/waiting_room.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "openssl"
+require "rack"
+require "active_support/concern"
+
+module Hibira
+  # Waiting rooms: send visitors to the Hibira queue, let them in with a pass.
+  #
+  # In a controller:
+  #
+  #   class DropsController < ApplicationController
+  #     waiting_room "presale", only: :show
+  #
+  #     def show
+  #       hibira_pass.number # also ticket_id, expires_at
+  #     end
+  #   end
+  #
+  # Or for path prefixes in any Rack app:
+  #
+  #   config.middleware.use Hibira::WaitingRoom::Middleware, "/drop" => "presale"
+  #
+  # A visitor without a valid pass is redirected to the hosted waiting page
+  # (non-GET requests get a 403). When it's their turn the page sends them
+  # back with ?hibira_pass=..., which is checked, stored in an HttpOnly cookie
+  # (hibira_wr_<room>) and removed from the URL.
+  module WaitingRoom
+    PURPOSE = "hibira-waitroom-pass."
+    PARAM = "hibira_pass"
+    ENV_KEY = "hibira.pass"
+
+    Pass = Struct.new(:app_id, :room, :number, :ticket_id, :issued_at, :expires_at, keyword_init: true)
+
+    class << self
+      # Returns the pass's claims, or nil when it is missing, forged, expired,
+      # or for another room or app. secret may be an array during a rotation.
+      def verify_pass(token, secret: Hibira.config.secret, room: nil, app_id: nil, now: Time.now.to_f)
+        return unless token.is_a?(String) && token.length <= 1024 && token.count(".") == 1
+
+        payload, sig = token.split(".", 2)
+        sig = decode(sig)
+        return if payload.empty? || sig.nil? || sig.bytesize != 32
+
+        message = PURPOSE + payload
+        valid = Array(secret).compact.reject(&:empty?).any? do |s|
+          Rack::Utils.secure_compare(OpenSSL::HMAC.digest("SHA256", s, message), sig)
+        end
+        return unless valid
+
+        claims = JSON.parse(decode(payload).to_s) rescue nil
+        return unless claims.is_a?(Hash) && claims["v"] == 1 && claims["exp"].is_a?(Numeric)
+        return if now >= claims["exp"]
+        return if room && claims["room"] != room
+        return if app_id && claims["app"] != app_id.to_s
+
+        Pass.new(app_id: claims["app"], room: claims["room"], number: claims["n"], ticket_id: claims["tid"],
+                 issued_at: claims["iat"], expires_at: claims["exp"].to_i)
+      end
+
+      # The hosted waiting page address for a room.
+      def url(room, return_url = nil, app_key: Hibira.config.key, host: nil, lang: nil)
+        base = "#{(host || default_host).chomp('/')}/wait/#{escape(app_key)}/#{escape(room)}"
+        query = { "return" => return_url, "lang" => lang }.compact
+        query.empty? ? base : "#{base}?#{Rack::Utils.build_query(query)}"
+      end
+
+      # Checks a Rack request. Returns nil to let it through (the claims are in
+      # env["hibira.pass"]), or the Rack response to send instead.
+      def check(env, room, secret: nil, app_key: nil, host: nil, lang: nil, cookie_name: nil)
+        secret ||= Hibira.config.secret
+        raise MissingCredentials, "Waiting rooms need HIBIRA_APP_SECRET" if Array(secret).compact.empty?
+
+        request = Rack::Request.new(env)
+        name = cookie_name || "hibira_wr_#{room}"
+        app_id = Hibira.config.app_id
+        clean = url_without_pass(request)
+
+        fresh = request.GET[PARAM]
+        if fresh && (claims = verify_pass(fresh, secret: secret, room: room, app_id: app_id))
+          headers = { "location" => clean, "cache-control" => "no-store" }
+          Rack::Utils.set_cookie_header!(headers, name,
+                                         value: fresh, path: "/", httponly: true, same_site: :lax,
+                                         secure: request.ssl?, max_age: [claims.expires_at - Time.now.to_i, 0].max)
+          return [302, headers, []]
+        end
+
+        claims = verify_pass(request.cookies[name], secret: secret, room: room, app_id: app_id)
+        if claims
+          env[ENV_KEY] = claims
+          return
+        end
+
+        if %w[GET HEAD].include?(request.request_method)
+          location = url(room, clean, app_key: app_key || Hibira.config.key, host: host, lang: lang)
+          [302, { "location" => location, "cache-control" => "no-store" }, []]
+        else
+          body = JSON.generate(error: "waiting_room", message: "join the waiting room first")
+          [403, { "content-type" => "application/json", "cache-control" => "no-store" }, [body]]
+        end
+      end
+
+      private
+
+      def default_host
+        c = Hibira.config
+        scheme = c.use_tls ? "https" : "http"
+        port = c.port == (c.use_tls ? 443 : 80) ? "" : ":#{c.port}"
+        "#{scheme}://#{c.host}#{port}"
+      end
+
+      def url_without_pass(request)
+        query = Rack::Utils.parse_query(request.query_string).except(PARAM)
+        base = request.base_url + request.path
+        query.empty? ? base : "#{base}?#{Rack::Utils.build_query(query)}"
+      end
+
+      def escape(value) = Rack::Utils.escape_path(value.to_s)
+
+      def decode(value)
+        return unless value.is_a?(String) && value.match?(/\A[A-Za-z0-9_-]+\z/)
+
+        Base64.urlsafe_decode64(value + ("=" * (-value.length % 4)))
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Rack middleware protecting path prefixes: { "/drop" => "presale" }. The
+    # longest matching prefix wins. options: secret, app_key, host, lang.
+    class Middleware
+      def initialize(app, rooms, options = {})
+        @app = app
+        @rooms = rooms.transform_keys(&:to_s).sort_by { |prefix, _| -prefix.length }
+        @options = options
+      end
+
+      def call(env)
+        path = env["PATH_INFO"].to_s
+        _, room = @rooms.find { |prefix, _| path == prefix || path.start_with?(prefix.end_with?("/") ? prefix : "#{prefix}/") }
+        (room && WaitingRoom.check(env, room, **@options)) || @app.call(env)
+      end
+    end
+
+    # Adds `waiting_room "room", only: ...` to controllers and `hibira_pass`.
+    module Controller
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def waiting_room(room, secret: nil, app_key: nil, host: nil, lang: nil, cookie_name: nil, **filter)
+          options = { secret: secret, app_key: app_key, host: host, lang: lang, cookie_name: cookie_name }
+          before_action(**filter) do
+            status, headers, body = WaitingRoom.check(request.env, room, **options)
+            if status
+              headers.each do |k, v|
+                case k
+                when "content-type" then response.content_type = v
+                when "location" then response.location = v
+                else response.set_header(k, v)
+                end
+              end
+              self.status = status
+              self.response_body = body
+            end
+          end
+        end
+      end
+
+      def hibira_pass = request.env[ENV_KEY]
+    end
+  end
+end

data/lib/hibira.rb

@@ -7,6 +7,7 @@ require "hibira/webhook"
 require "hibira/turbo"
 require "hibira/streams_helper"
 require "hibira/check"
+require "hibira/waiting_room"
 
 # Rails integration for Hibira (https://hibira.io): Turbo Streams, private and
 # presence channel auth, webhooks and push notifications over the Pusher

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hibira-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Hibira
@@ -118,6 +118,7 @@ files:
 - lib/hibira/streams_helper.rb
 - lib/hibira/turbo.rb
 - lib/hibira/version.rb
+- lib/hibira/waiting_room.rb
 - lib/hibira/webhook.rb
 - lib/tasks/hibira.rake
 homepage: https://hibira.io