monkrb 0.18.0 → 0.20.0

data/lib/monk/websocket/redis_fanout.rb

@@ -1,5 +1,7 @@
 require "redis"
 require "securerandom"
+require_relative "errors"
+require_relative "listeners"
 
 module Monk
   module WebSocket
@@ -9,7 +11,7 @@ module Monk
     # LISTEN/NOTIFY per docs/design/websocket.md Open Question 3).
     #
     # Wraps a Registry with the same public interface (#register,
-    # #unregister, #count, #broadcast), so an app swaps which object it
+    # #unregister, #count, #broadcast, #listen!), so an app swaps which object it
     # holds and nothing else changes. #broadcast still delivers to this
     # process's local Registry directly -- same latency and reliability as
     # a plain Registry if Redis is briefly unavailable -- and additionally
@@ -36,49 +38,139 @@ module Monk
       # already shareable.
       CHANNEL_PREFIX = "monk:ws:".freeze
 
+      # The body of #listen!'s subscriber Ractor. A class method because
+      # the Ractor has no RedisFanout instance to call into. Reports :ok,
+      # or why it couldn't subscribe, on `ready`, then relays messages for
+      # the rest of the process's life.
+      #
+      # A dropped connection (a Redis restart, a failover) is resubscribed
+      # with backoff. Messages published while it was down are lost, so
+      # once subscribed again every open socket is closed
+      # (Listeners::MISSED_CODE), and each client reconnects and resyncs.
+      def self.subscribe(registry, url, own_origin, ready)
+        listening = false
+        delay = Listeners::RETRY_INITIAL
+        loop do
+          Redis.new(url: url).psubscribe("#{CHANNEL_PREFIX}*") do |on|
+            on.psubscribe do
+              delay = Listeners::RETRY_INITIAL
+              if listening
+                closed = registry.close_all(Listeners::MISSED_CODE, Listeners::MISSED_REASON)
+                log(:info, "subscribed again; closed #{closed} socket(s) so their pages resync")
+              else
+                listening = true
+                ready.send(:ok)
+              end
+            end
+            on.pmessage { |_pattern, channel, envelope| relay(registry, own_origin, channel, envelope) }
+          end
+        rescue StandardError => e
+          # Not narrower: redis-rb lets redis-client's own
+          # RedisClient::ConnectionError out of psubscribe, not a
+          # Redis::BaseConnectionError. #relay rescues its own errors, so
+          # what gets here is the connection.
+          return ready.send("#{e.class}: #{e.message}") unless listening
+
+          log(:error, "subscriber connection failed (#{e.class}: #{e.message}); retrying in #{delay}s")
+          sleep delay
+          delay = Listeners.next_delay(delay)
+        end
+      end
+
+      # One message into this process's registry. Anything that goes wrong
+      # here drops this message only: escaping, it would end the
+      # subscriber Ractor, and with it every later broadcast, silently.
+      #
+      # Redis channel names are always Strings, but Registry's own keys
+      # are ordinary Hash keys the app chooses -- every existing caller
+      # (Registry's own tests, the websocket_server scaffold's :chat
+      # channel) uses a Symbol. #to_sym here is what makes
+      # registry.broadcast(:chat, ...) land on the same Hash key
+      # #register(:chat, port) used -- without it this silently
+      # broadcasts to an unrelated "chat" String key that nothing is ever
+      # registered under, and #broadcast still returns true either way
+      # (Registry#broadcast succeeds whether or not any port is registered
+      # for a key).
+      def self.relay(registry, own_origin, channel, envelope)
+        sender, payload = envelope.split("\0", 2)
+        raise ArgumentError, "no origin separator in the message" unless payload
+        return if sender == own_origin
+
+        registry.broadcast(channel.delete_prefix(CHANNEL_PREFIX).to_sym, payload)
+      rescue StandardError => e
+        log(:error, "dropped a message on #{channel}: #{e.class}: #{e.message}")
+      end
+
+      def self.log(level, message) = Listeners.log(name, level, message)
+      private_class_method :relay, :log
+
+      # Closes the calling Ractor's publisher client (#publisher), if it
+      # opened one; the next broadcast in this Ractor reconnects.
+      # Server.serve runs it as each socket ends, as PgFanout's.
+      def self.disconnect_publisher
+        client = Ractor.current[:monk_redis_fanout_publisher]
+        return unless client
+
+        Ractor.current[:monk_redis_fanout_publisher] = nil
+        client.close
+      end
+
       def initialize(registry, redis_url:)
         @registry = registry
         @redis_url = redis_url.dup.freeze
         @origin = SecureRandom.uuid.freeze
 
+        # No live connection lives on this object -- #listen! runs its
+        # subscriber in a Ractor of its own, and #publisher below opens one
+        # client per Ractor, lazily -- so there's nothing left unshareable
+        # and this instance can freeze itself the same way Registry does.
+        # That matters for real use: an app holds this behind a module
+        # constant (e.g. ChatServer::REGISTRY, mirroring Registry's own
+        # existing usage) read from every connection's own Ractor, which
+        # raises Ractor::IsolationError unless the constant's value is
+        # shareable.
+        freeze
+      end
+
+      # Starts relaying other processes' broadcasts into this process's
+      # registry: a subscriber Ractor with its own Redis connection. Only
+      # the process that holds sockets calls this (bin/websocket_server, at
+      # boot, from the main Ractor) -- a publish-only process (bin/server,
+      # bin/jobs) never does, so it holds no subscriber connection at all.
+      # Returns once the psubscribe is in effect, so nothing broadcast
+      # after it can be missed; raises ListenError if Redis can't be
+      # reached. Calling it again is a no-op.
+      def listen!
+        return self if Listeners.listening?(@origin)
+
+        ready = Ractor::Port.new
         # Ractor.new's block args must be shareable: registry is (Registry
         # freezes itself around a Ractor, which is inherently shareable),
-        # redis_url and @origin are plain frozen Strings. The Redis client
-        # itself is built inside the block, never passed in -- mirrors
-        # PG::Connection's per-Ractor pattern (persistence/pg.rb).
-        @subscriber = Ractor.new(registry, @redis_url, @origin) do |registry, url, origin|
-          Redis.new(url: url).psubscribe("#{Monk::WebSocket::RedisFanout::CHANNEL_PREFIX}*") do |on|
-            on.pmessage do |_pattern, channel, envelope|
-              sender, payload = envelope.split("\0", 2)
-              next if sender == origin
-
-              # Redis channel names are always Strings, but Registry's own
-              # keys are ordinary Hash keys the app chooses -- every
-              # existing caller (Registry's own tests, the websocket_server
-              # scaffold's :chat channel) uses a Symbol. #to_sym here is
-              # what makes registry.broadcast(:chat, ...) land on the same
-              # Hash key #register(:chat, port) used -- without it this
-              # silently broadcasts to an unrelated "chat" String key that
-              # nothing is ever registered under, and #broadcast still
-              # returns true either way (Registry#broadcast succeeds
-              # whether or not any port is registered for a key).
-              key = channel.delete_prefix(Monk::WebSocket::RedisFanout::CHANNEL_PREFIX).to_sym
-              registry.broadcast(key, payload)
-            end
-          end
+        # the URL and origin are frozen Strings, a Port always is. The
+        # Redis client itself is built inside the block, never passed in --
+        # mirrors PG::Connection's per-Ractor pattern (persistence/pg.rb).
+        Ractor.new(@registry, @redis_url, @origin, ready) do |registry, url, origin, ready|
+          Monk::WebSocket::RedisFanout.subscribe(registry, url, origin, ready)
         end
 
-        # No live connection lives on this object -- #publisher below opens
-        # one per Ractor, lazily -- so there's nothing left unshareable and
-        # this instance can freeze itself the same way Registry does. That
-        # matters for real use: an app holds this behind a module constant
-        # (e.g. ChatServer::REGISTRY, mirroring Registry's own existing
-        # usage) read from every connection's own Ractor, which raises
-        # Ractor::IsolationError unless the constant's value is shareable.
-        freeze
+        result = ready.receive
+        raise ListenError, "Monk::WebSocket::RedisFanout#listen! couldn't subscribe: #{result}" unless result == :ok
+
+        Listeners.add(@origin)
+        self
+      end
+
+      def register(key, port)
+        unless Listeners.listening?(@origin)
+          raise NotListeningError,
+            "Monk::WebSocket::RedisFanout#register before #listen!: this socket would never get " \
+            "other processes' broadcasts -- call listen! once at boot in the process that holds " \
+            "sockets (bin/websocket_server: Monk::Live.listen!)"
+        end
+
+        @registry.register(key, port)
       end
 
-      def register(key, port) = @registry.register(key, port)
       def unregister(key, port) = @registry.unregister(key, port)
       def count(key) = @registry.count(key)
 

data/lib/monk/websocket/registry.rb

@@ -1,5 +1,10 @@
 module Monk
   module WebSocket
+    # Sent through a registered port instead of a payload: the socket
+    # behind it closes with this code and reason. Registry#close_all sends
+    # it; Connection's and Live::Session's relays act on it.
+    CloseRequest = Data.define(:code, :reason)
+
     # A dedicated Ractor holding the live set of connection handles keyed by
     # an app-assigned channel/subject -- mirrors StateRactor's shape
     # (docs/design/ractor.md): the mutable Hash stays hidden inside this one
@@ -41,6 +46,17 @@ module Monk
                 true
               when :count
                 keys[key].size
+              when :close_all
+                # Once per port: a Live page holds one port for all its
+                # topics. Entries stay until each connection's own cleanup
+                # unregisters them, as on any other close.
+                ports = keys.values.flatten.uniq
+                ports.each do |port|
+                  port.send(arg)
+                rescue Ractor::ClosedError
+                  nil
+                end
+                ports.size
               end
             reply_port.send(result)
           end
@@ -67,6 +83,20 @@ module Monk
         ask(:count, key, nil)
       end
 
+      # Closes every registered connection's socket with code and reason,
+      # so each client reconnects -- a fanout's subscriber does this after
+      # missing broadcasts, to make every page resync. Returns how many
+      # connections were asked to close.
+      def close_all(code, reason)
+        ask(:close_all, nil, Ractor.make_shareable(CloseRequest.new(code: code, reason: reason.to_s)))
+      end
+
+      # Nothing to listen to: every broadcast reaching this registry comes
+      # from this process. Here so a WS process calls #listen! the same
+      # way whether it holds a Registry or a RedisFanout/PgFanout around
+      # one.
+      def listen! = self
+
       private
 
       def ask(op, key, arg)

data/lib/monk/websocket/server.rb

@@ -25,9 +25,29 @@ module Monk
       # docs/history/chat-gap-analysis.md) -- authenticate: true only checks the
       # credential once, at the handshake, so a session revoked or
       # expired afterward would otherwise leave the socket live
-      # indefinitely. Requires authenticate: true (there's no credential
-      # to reverify without it) and defaults to nil (disabled), same as
-      # ping_interval:.
+      # indefinitely. Requires authenticate: true or :optional (there's no
+      # credential to reverify without it) and defaults to nil (disabled),
+      # same as ping_interval:. Under :optional it watches only the
+      # connections that have a session.
+      #
+      # authenticate: :optional is the middle mode (docs/design/websocket.md,
+      # "Anonymous connections"): a connection with a valid session gets its
+      # subject, and one without -- no credential, or a revoked or expired
+      # one -- comes in anonymous (subject nil) instead of being refused.
+      # What an anonymous connection may then do is the handler's call:
+      # Monk::Live's rules deny it everything a rule doesn't open with
+      # `anonymous: true`. The Origin check still applies: to a cookie, as
+      # under true, and to an anonymous connection that sends an Origin,
+      # since only a browser does.
+      #
+      # db_pool: (a pool name, docs/history/plan-pg-pool.md) runs those
+      # Monk::Auth.verify calls -- the handshake's and reverify_interval's
+      # -- in that Monk::Persistence::Pg pool instead of in the socket's
+      # own Ractor. Without it, each socket's Ractor opens a connection of
+      # its own on the first verify and holds it while the socket is open:
+      # one Postgres connection per open page. With it, the server holds
+      # the pool's. Requires authenticate:, and the pool started
+      # (start_pools!) before the server.
       #
       # max_payload_size: (bytes) -- see Connection::DEFAULT_MAX_PAYLOAD_SIZE
       # for what it guards against (gap 5). Unlike ping_interval:/
@@ -35,21 +55,32 @@ module Monk
       # hostile client on a public endpoint, not an opt-in behavior
       # change, so a server that doesn't mention it still gets the
       # default cap rather than no cap at all.
+      AUTHENTICATE_MODES = [false, true, :optional].freeze
+
+      # The signals #run treats as "stop": Ctrl+C and TERM.
+      STOP_SIGNALS = [Signal.list.fetch("INT"), Signal.list.fetch("TERM")].freeze
+
       def initialize(
         port:, bind: "0.0.0.0", allowed_origins: nil, authenticate: false, ping_interval: nil,
-        reverify_interval: nil, max_payload_size: Connection::DEFAULT_MAX_PAYLOAD_SIZE
+        reverify_interval: nil, max_payload_size: Connection::DEFAULT_MAX_PAYLOAD_SIZE, db_pool: nil
       )
         if ping_interval && !ping_interval.positive?
           raise ArgumentError, "ping_interval must be positive, got #{ping_interval.inspect}"
         end
 
+        unless AUTHENTICATE_MODES.include?(authenticate)
+          raise ArgumentError, "authenticate must be false, true or :optional, got #{authenticate.inspect}"
+        end
+
         if reverify_interval
           unless reverify_interval.positive?
             raise ArgumentError, "reverify_interval must be positive, got #{reverify_interval.inspect}"
           end
-          raise ArgumentError, "reverify_interval requires authenticate: true" unless authenticate
+          raise ArgumentError, "reverify_interval requires authenticate: true or :optional" unless authenticate
         end
 
+        raise ArgumentError, "db_pool requires authenticate: true or :optional" if db_pool && !authenticate
+
         unless max_payload_size.positive?
           raise ArgumentError, "max_payload_size must be positive, got #{max_payload_size.inspect}"
         end
@@ -57,8 +88,8 @@ module Monk
         if authenticate
           unless defined?(Monk::Auth) && Monk::Auth.config
             raise Monk::AuthNotConfiguredError,
-              "Monk::WebSocket::Server.new(authenticate: true) requires Monk::Auth to already be " \
-              "configured -- call Monk::Auth.configure first"
+              "Monk::WebSocket::Server.new(authenticate: #{authenticate.inspect}) requires Monk::Auth to " \
+              "already be configured -- call Monk::Auth.configure first"
           end
 
           # Monk::Auth's config is a plain, unfrozen Hash until this runs
@@ -71,12 +102,17 @@ module Monk
           Monk.freeze!
         end
 
+        # Raises now, not on the first connection, if the pool was never
+        # declared or isn't started in this process.
+        Monk::Persistence::Pg.pool(db_pool) if db_pool
+
         @tcp_server = TCPServer.new(bind, port)
         @allowed_origins = allowed_origins ? Ractor.make_shareable(allowed_origins.dup) : nil
         @authenticate = authenticate
         @ping_interval = ping_interval
         @reverify_interval = reverify_interval
         @max_payload_size = max_payload_size
+        @db_pool = db_pool
       end
 
       def port
@@ -97,25 +133,33 @@ module Monk
         loop do
           socket = @tcp_server.accept
           ractor = Ractor.new(
-            shareable_block, @authenticate, @allowed_origins, @ping_interval, @reverify_interval, @max_payload_size
-          ) do |blk, authenticate, origins, ping_interval, reverify_interval, max_payload_size|
+            shareable_block, @authenticate, @allowed_origins, @ping_interval, @reverify_interval, @max_payload_size,
+            @db_pool
+          ) do |blk, authenticate, origins, ping_interval, reverify_interval, max_payload_size, db_pool|
             Monk::WebSocket::Server.serve(
               Ractor.receive, blk,
-              authenticate: authenticate, allowed_origins: origins,
-              ping_interval: ping_interval, reverify_interval: reverify_interval, max_payload_size: max_payload_size
+              authenticate: authenticate, allowed_origins: origins, ping_interval: ping_interval,
+              reverify_interval: reverify_interval, max_payload_size: max_payload_size, db_pool: db_pool
             )
           end
           ractor.send(socket, move: true)
         end
-      rescue Interrupt
-        # Ctrl+C's default Ruby behavior: raise Interrupt in the thread
-        # blocked in the syscall, here TCPServer#accept. Unrescued, that's
-        # an unhandled exception -- Ruby prints its backtrace and exits
-        # non-zero, which reads as a crash even though this is the normal,
-        # intended way to stop a long-running server. Registry#ask's
-        # Ractor::ClosedError rescue (registry.rb) guards a different
-        # failure point in this same shutdown -- a live connection's
-        # cleanup racing the registry Ractor's teardown -- not this one.
+      rescue SignalException => e
+        raise unless STOP_SIGNALS.include?(e.signo)
+
+        # Ctrl+C (INT, raised as Interrupt) and TERM (what docker stop,
+        # Kubernetes, Fly, Render and systemd send on every deploy) both
+        # land here: Ruby raises them in the thread blocked in
+        # TCPServer#accept. Unrescued, INT prints a backtrace and TERM ends
+        # the process by the signal (exit 143) -- either reads as a crash
+        # though it's the normal way to stop a long-running server. Here
+        # the server stops accepting and #run returns, so the script ends
+        # with exit 0, as bin/server and bin/jobs do. Open connections are
+        # dropped when the process exits, with no close frame
+        # (docs/design/websocket.md, "Stopping the server").
+        # Registry#ask's Ractor::ClosedError rescue (registry.rb) guards a
+        # different failure point in this same shutdown -- a live
+        # connection's cleanup racing the registry Ractor's teardown.
         @tcp_server.close
       end
 
@@ -125,7 +169,7 @@ module Monk
       # TCPServer) is never Ractor-shareable and can't cross into here.
       def self.serve(
         socket, block, authenticate: false, allowed_origins: nil, ping_interval: nil, reverify_interval: nil,
-        max_payload_size: Connection::DEFAULT_MAX_PAYLOAD_SIZE
+        max_payload_size: Connection::DEFAULT_MAX_PAYLOAD_SIZE, db_pool: nil
       )
         request = read_handshake_request(socket)
         return socket.close unless request
@@ -138,9 +182,14 @@ module Monk
           end
 
         subject = nil
-        if authenticate
-          subject = authenticate!(socket, headers, allowed_origins)
+        case authenticate
+        when true
+          subject = authenticate!(socket, headers, allowed_origins, db_pool)
           return unless subject
+        when :optional
+          return unless origin_allowed_for_optional?(socket, headers, allowed_origins)
+
+          subject = identify(headers, db_pool)
         end
 
         socket.write(Handshake.response_for(request))
@@ -148,8 +197,8 @@ module Monk
         connection = Connection.new(socket, subject: subject, max_payload_size: max_payload_size)
         connection.start_heartbeat(ping_interval) if ping_interval
         reverify_thread =
-          if reverify_interval
-            start_reverify(connection, Handshake.credential_from(headers)[:token], reverify_interval)
+          if reverify_interval && subject
+            start_reverify(connection, Handshake.credential_from(headers)[:token], reverify_interval, db_pool)
           end
         begin
           block.call(connection)
@@ -169,7 +218,21 @@ module Monk
         connection&.unsubscribe!
         connection&.stop_heartbeat!
         socket.close
+        disconnect_all
+      end
+
+      # Closes the connections this socket's Ractor opened: its database
+      # connection (verifying the session without db_pool:, or a block
+      # that queries) and a fan-out's publisher (a block that broadcasts).
+      # Left alone, each would stay open until the garbage collector
+      # happened to run, which a mostly idle server may not do for a long
+      # time. The fan-outs are opt-in, so each is closed only if loaded.
+      def self.disconnect_all
+        Monk::Persistence.disconnect_all
+        PgFanout.disconnect_publisher if defined?(PgFanout)
+        RedisFanout.disconnect_publisher if defined?(RedisFanout)
       end
+      private_class_method :disconnect_all
 
       # docs/history/plan-websocket.md steps 22-23: the Origin allowlist check runs
       # before Monk::Auth.verify, and only for a cookie-derived
@@ -177,7 +240,7 @@ module Monk
       # by construction (mirrors require_csrf!'s own Bearer exemption in
       # docs/history/plan-auth.md). Returns the verified subject, or nil after writing
       # the appropriate 403/401 response itself.
-      def self.authenticate!(socket, headers, allowed_origins)
+      def self.authenticate!(socket, headers, allowed_origins, db_pool)
         credential = Handshake.credential_from(headers)
 
         if credential&.fetch(:via) == :cookie && allowed_origins
@@ -188,12 +251,40 @@ module Monk
           end
         end
 
-        subject = credential && Monk::Auth.verify(credential[:token])
+        subject = credential && verify(credential[:token], db_pool)
         socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n") unless subject
         subject
       end
       private_class_method :authenticate!
 
+      # authenticate: :optional's Origin check, before anything is verified.
+      # A Bearer connection is exempt, as under true. A cookie needs an
+      # allowed Origin, as under true. An anonymous connection that sends an
+      # Origin needs an allowed one too: only a browser sends it, and this
+      # stops another site's page from opening sockets here on its
+      # visitors' behalf; one that sends none (not a browser) gets in.
+      # Writes the 403 itself and returns false when refused.
+      def self.origin_allowed_for_optional?(socket, headers, allowed_origins)
+        return true unless allowed_origins
+
+        credential = Handshake.credential_from(headers)
+        return true if credential&.fetch(:via) == :bearer
+
+        origin = headers["origin"]
+        allowed = credential ? origin && allowed_origins.include?(origin) : origin.nil? || allowed_origins.include?(origin)
+        socket.write("HTTP/1.1 403 Forbidden\r\n\r\n") unless allowed
+        allowed
+      end
+      private_class_method :origin_allowed_for_optional?
+
+      # The subject of a valid session, or nil -- no credential, or one
+      # Monk::Auth no longer accepts, both mean anonymous under :optional.
+      def self.identify(headers, db_pool)
+        credential = Handshake.credential_from(headers)
+        credential && verify(credential[:token], db_pool)
+      end
+      private_class_method :identify
+
       # Sleeps in `interval`-sized steps, re-running Monk::Auth.verify
       # against the same raw credential each time, until it comes back
       # nil (revoked or expired) -- then closes the connection with the
@@ -203,11 +294,11 @@ module Monk
       # own Thread rather than blocking the handler's own read loop,
       # mirroring Connection#start_heartbeat's shape; killed from #serve's
       # ensure the same way.
-      def self.start_reverify(connection, raw_token, interval)
+      def self.start_reverify(connection, raw_token, interval, db_pool)
         Thread.new do
           loop do
             sleep interval
-            break unless Monk::Auth.verify(raw_token)
+            break unless verify(raw_token, db_pool)
           end
           connection.close(code: 1008, reason: "session no longer valid")
         rescue IOError, Errno::EPIPE, Errno::ECONNRESET
@@ -218,6 +309,14 @@ module Monk
       end
       private_class_method :start_reverify
 
+      # Monk::Auth.verify, here or in the db_pool: pool (Server.new).
+      def self.verify(raw_token, db_pool)
+        return Monk::Auth.verify(raw_token) unless db_pool
+
+        Monk::Persistence::Pg.pool(db_pool).call(Monk::Auth, :verify, raw_token)
+      end
+      private_class_method :verify
+
       def self.read_handshake_request(socket)
         request = +""
         until request.end_with?("\r\n\r\n")

data/lib/monk/websocket.rb

@@ -3,6 +3,8 @@ require_relative "errors"
 # true) always raises this precise error, per ADR 0003, rather than a bare
 # NameError when an app calls it without ever requiring "monk/auth" at all.
 require_relative "auth/errors"
+# Dependency-free too: Server.serve closes a socket Ractor's connections.
+require_relative "persistence"
 require_relative "websocket/errors"
 require_relative "websocket/handshake"
 require_relative "websocket/frame"

data/lib/monk.rb

@@ -24,6 +24,8 @@ module Monk
     parts << " - auth=on" if defined?(Auth) && Auth.config
     backends = persistence_backends
     parts << " - persistence=#{backends.join(",")}" unless backends.empty?
+    pools = running_pools
+    parts << " - pools=#{pools.join(",")}" unless pools.empty?
     parts << "\n"
 
     $stdout.puts parts.join("\n")
@@ -42,4 +44,12 @@ module Monk
       .filter_map { |hook| "#{hook.name.split("::").last.downcase}:#{hook.names.join(",")}" if hook.names.any? }
   end
   private_class_method :persistence_backends
+
+  # "name(size)" for every pool started in this process, by any backend.
+  def self.running_pools
+    freeze_hooks
+      .select { |hook| hook.is_a?(Module) && hook.singleton_class.include?(Persistence::Registry) }
+      .flat_map { |hook| hook.running_pools.map { |name, size| "#{name}(#{size})" } }
+  end
+  private_class_method :running_pools
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: monkrb
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Matteo Folin
@@ -212,38 +212,48 @@ files:
 - lib/monk/persistence/pg/errors.rb
 - lib/monk/persistence/pg/migrator.rb
 - lib/monk/persistence/pg/model.rb
+- lib/monk/persistence/pool.rb
 - lib/monk/scaffold.rb
 - lib/monk/settings.rb
 - lib/monk/state_ractor.rb
+- lib/monk/templates/auth/app/mailers/app_mailer.rb
+- lib/monk/templates/auth/app/views/mail/magic_link.erb
 - lib/monk/templates/auth/config/auth.rb
 - lib/monk/templates/auth/db/migrate/00000000000001_create_auth_tables.down.sql
 - lib/monk/templates/auth/db/migrate/00000000000001_create_auth_tables.up.sql
-- lib/monk/templates/auth/views/mail/magic_link.erb
 - lib/monk/templates/base/.dockerignore
 - lib/monk/templates/base/.gitignore
 - lib/monk/templates/base/.ruby-version
 - lib/monk/templates/base/Dockerfile
 - lib/monk/templates/base/Gemfile
+- lib/monk/templates/base/app/app.rb
+- lib/monk/templates/base/app/broadcasts/.keep
+- lib/monk/templates/base/app/helpers/.keep
+- lib/monk/templates/base/app/jobs/.keep
+- lib/monk/templates/base/app/mailers/.keep
+- lib/monk/templates/base/app/models/.keep
+- lib/monk/templates/base/app/presenters/.keep
+- lib/monk/templates/base/app/views/index.erb
+- lib/monk/templates/base/app/views/layouts/app.erb
 - lib/monk/templates/base/bin/server
 - lib/monk/templates/base/bin/websocket_server
 - lib/monk/templates/base/config.ru
+- lib/monk/templates/base/config/load.rb
 - lib/monk/templates/base/config/settings.rb
 - lib/monk/templates/base/public/css/app.css
 - lib/monk/templates/base/public/js/app.js
-- lib/monk/templates/base/views/index.erb
-- lib/monk/templates/base/views/layouts/app.erb
+- lib/monk/templates/jobs/app/jobs/hello_job.rb
+- lib/monk/templates/jobs/app/jobs/send_login_link.rb
 - lib/monk/templates/jobs/bin/jobs
 - lib/monk/templates/jobs/config/jobs.rb
 - lib/monk/templates/jobs/db/migrate/00000000000002_create_jobs_tables.down.sql
 - lib/monk/templates/jobs/db/migrate/00000000000002_create_jobs_tables.up.sql
-- lib/monk/templates/jobs/jobs/hello_job.rb
-- lib/monk/templates/jobs/jobs/send_login_link.rb
+- lib/monk/templates/live/app/app.rb
+- lib/monk/templates/live/app/views/index.erb
+- lib/monk/templates/live/app/views/live/_hits.erb
 - lib/monk/templates/live/bin/websocket_server
-- lib/monk/templates/live/config.ru
 - lib/monk/templates/live/config/live.rb
 - lib/monk/templates/live/config/live_pg.rb
-- lib/monk/templates/live/views/index.erb
-- lib/monk/templates/live/views/live/_hits.erb
 - lib/monk/templates/mail/Gemfile.extra
 - lib/monk/templates/mail/config/mail.rb
 - lib/monk/templates/postgres/Dockerfile
@@ -252,6 +262,7 @@ files:
 - lib/monk/templates/postgres/bin/migrate
 - lib/monk/templates/postgres/bin/setup_db
 - lib/monk/templates/postgres/config/persistence.rb
+- lib/monk/templates/postgres/db/migrate/.keep
 - lib/monk/templates/redis/Gemfile.extra
 - lib/monk/version.rb
 - lib/monk/views.rb
@@ -260,6 +271,7 @@ files:
 - lib/monk/websocket/errors.rb
 - lib/monk/websocket/frame.rb
 - lib/monk/websocket/handshake.rb
+- lib/monk/websocket/listeners.rb
 - lib/monk/websocket/pg_fanout.rb
 - lib/monk/websocket/redis_fanout.rb
 - lib/monk/websocket/registry.rb