asterism-games 0.21.0 → 0.23.0

data/lib/asterism_games/commentate/mahjong.rb

@@ -266,10 +266,111 @@ module AsterismGames
       end
     end
 
+    # Asterism's protocol 2 keeps no current value on the network: a
+    # reader asks the sender for it (Host#spectate_now, the object
+    # <node>/<app>/spectate) at the first value of a table from a sender,
+    # and again when it missed values (info.lost > 0) or saw the sender
+    # start again (info.restarted?; both counted per sender on the shared
+    # place). A sender that left the network (on_app_leave) is forgotten:
+    # Asterism then forgets its numbers too, so its next value comes as a
+    # first one (lost 0, not restarted), and is asked for again. The
+    # answer goes to the hub unless a newer value came while asking. The
+    # asking is on a thread of its own: the values come on the receiving
+    # thread, where no call may wait.
+    class Refetch
+      attr_reader :asked, :taken
+
+      # call: ->(from, name) { the current value } ("<node>/<app>" of the
+      # sender, the table's name under spectate/); log: ->(message).
+      def initialize(hub, call:, log: ->(_m) {})
+        @hub = hub
+        @call = call
+        @log = log
+        @lock = Monitor.new
+        @seen = Hash.new(0) # table id => values given to the hub
+        @from = {}          # table id => the sender of its last value
+        @want = {}          # table id => [from, host, name, @seen when asked]
+        @queue = Thread::Queue.new
+        @asked = 0
+        @taken = 0
+      end
+
+      # A value of a table came (the receiving thread): blk gives it to
+      # the hub; at a sender's first value, after lost values or when the
+      # sender started again, the current one is asked for (once at a time
+      # per table). Returns blk's.
+      def came(info, host, name, &blk)
+        id = MahjongHub.id(host, name)
+        why = nil
+        out = @lock.synchronize do
+          r = blk.call
+          @seen[id] += 1
+          from = info.from.to_s
+          first = @from[id] != from
+          @from[id] = from
+          why = if !from.include?("/") || @want.key?(id) then nil
+                elsif info.restarted? then "#{from} started again"
+                elsif info.lost.to_i.positive? then "#{info.lost} value(s) lost"
+                elsif first then "the first value from #{from}"
+                end
+          @want[id] = [from, host, name, @seen[id]] if why
+          r
+        end
+        if why
+          @log.call("#{id}: #{why}; asking #{info.from}/#{Commentate::MahjongRunner::SPECTATE_OBJECT} for the table now")
+          @queue << id
+        end
+        out
+      end
+
+      # A sender ("<node>/<app>") left the network: its next value is a
+      # first one.
+      def forget(from)
+        @lock.synchronize { @from.delete_if { |_id, f| f == from } }
+      end
+
+      # Asks for one table's current value and gives it to the hub (a
+      # newer value that came meanwhile wins). :taken, :newer, :none (the
+      # sender has nothing yet) or :error.
+      def run_one(id)
+        from, host, name, at = @lock.synchronize { @want[id] }
+        return :none unless from
+        @asked += 1
+        v = @call.call(from, name)
+        @lock.synchronize do
+          @want.delete(id)
+          return :newer if @seen[id] != at
+          return :none unless v.is_a?(Hash)
+          @hub.update(host, name, v)
+          @seen[id] += 1
+        end
+        @taken += 1
+        @log.call("#{id}: took the table now from #{from}")
+        :taken
+      rescue StandardError => e
+        @lock.synchronize { @want.delete(id) }
+        @log.call("#{id}: asking #{from}/#{Commentate::MahjongRunner::SPECTATE_OBJECT}: #{e.class}: #{e.message}")
+        :error
+      end
+
+      def start
+        @thread = Thread.new { loop { run_one(@queue.pop) } }
+        self
+      end
+
+      def stop
+        @thread&.kill
+      end
+    end
+
     # `asterism-games commentate mahjong`: the connection, the spectate
     # keys, the web server and the browser.
     module MahjongRunner
-      SPECTATE = "asterism/*/spectate/*/state"
+      # The spectate keys in every node's shared place (README "Spectate").
+      SPECTATE = "*/@shared/spectate/*/state"
+      # The sender's object that answers a table's current spectate value
+      # (Host::SPECTATE_OBJECT): <node>/<app>/spectate, state(table).
+      SPECTATE_OBJECT = "spectate"
       STALE_S = 15
 
       module_function
@@ -289,18 +390,20 @@ module AsterismGames
         info.puts "commentate: hands hidden (--public)" if opts[:public]
         open_browser(server.url, err) if opts[:open]
         prefix = room_prefix(opts[:namespace])
+        refetch = nil
         connect(opts, err) do |net|
           net.on_leave { |n| hub.host_left(n) }
           net.on_join { |n| hub.host_back(n) }
+          refetch = Refetch.new(hub, call: ->(from, name) { net["#{from}/#{SPECTATE_OBJECT}", timeout: 2].state(name) },
+                                     log: ->(m) { err.puts "commentate: #{m}" }).start
+          net.on_app_leave { |n, a| refetch.forget("#{n}/#{a}") }
           net.start
-          net.session.subscribe(SPECTATE) do |sample|
-            next if sample.respond_to?(:kind) && sample.kind == :delete
-            _, host, _, name, = sample.key.to_s.split("/")
+          net.subscribe(SPECTATE) do |v, info|
+            host, name = spectate_source(info)
             next unless wanted?(host, name, opts[:table], prefix)
-            v = Asterism::Codec.unpack(sample.payload)
-            hub.update(host, name, v)
+            refetch.came(info, host, name) { hub.update(host, name, v) }
           rescue StandardError => e
-            err.puts "commentate: #{sample.key}: #{e.class}: #{e.message}"
+            err.puts "commentate: #{info.key}: #{e.class}: #{e.message}"
           end
           stop = Thread::Queue.new
           %w[INT TERM].each { |s| trap(s) { stop << true } }
@@ -310,6 +413,7 @@ module AsterismGames
           end
         end
       ensure
+        refetch&.stop
         server&.stop
         voice&.stop
         ai&.stop
@@ -349,6 +453,17 @@ module AsterismGames
         end
       end
 
+      # [host node, table] of a spectate value: the node of its sender
+      # (info.from, "<node>/<app>": the host's games or a room's room<slot>,
+      # the same node), else the key's; the table from the name under
+      # @shared/ (spectate/<table>/state).
+      def spectate_source(info)
+        from = info.from.to_s
+        host = from.include?("/") ? from.split("/").first : info.node
+        parts = info.name.to_s.split("/")
+        [host, parts[0] == "spectate" ? parts[1] : nil]
+      end
+
       # --namespace room/01: the room's tables are room01-<table> outside it.
       def room_prefix(ns)
         return nil if ns.to_s.empty?
@@ -363,8 +478,8 @@ module AsterismGames
         parts.size >= 3 ? "#{parts[0]}/#{parts[-1]}" : t
       end
 
-      # --table: <table>, <host>/<table>, <host>/spectate/<table> or the
-      # play's <host>/games/<table>.
+      # --table: <table>, <host>/<table>, <host>/@shared/spectate/<table>
+      # or the play's <host>/games/<table>.
       def wanted?(host, name, table, prefix)
         return false if host.nil? || name.nil?
         return false if prefix && !name.start_with?(prefix)

data/lib/asterism_games/commentate.rb

@@ -34,7 +34,7 @@ module AsterismGames
         --namespace PREFIX    a room's tables (room/01: their spectate keys room01-<table>,
                               outside the room; the connection itself has no namespace)
         --table TABLE         the table to show first (<table>, <host>/<table>, or
-                              <host>/spectate/<table>); without it every table that puts
+                              <host>/@shared/spectate/<table>); without it every table that puts
                               its spectate key is listed and the first one shown
         --node NODE           the node ID (default: commentate-<host>-<pid>, or the .tar's name)
         --port N              the page's port on 127.0.0.1 (default %<port>d; taken: the next free)

data/lib/asterism_games/game.rb

@@ -36,6 +36,17 @@ module AsterismGames
   #   SAVE_HOLD_MS           at most one write of the saved state this often (0: after
   #                          every change); a game that changes many times a second
   #                          (the board's strokes) holds its writes
+  #   TYPES                  the types of what the host puts (asterism's docs/protocol.md
+  #                          11.2): {name => [[[field, type], ...], text]}, told to the
+  #                          readers by the host's @profile?types
+  #   STATE_TYPE             the type of <table>/state (a name of TYPES; nil: none)
+  #   TOLD_TYPES             {sub => type} of what the game tells (tell(sub, value))
+  #   SPECTATE_TYPE          the type of what spectate_view gives (a name of
+  #                          SPECTATE_TYPES; nil: none), the topic
+  #                          spectate/<table>/state of the node's shared place
+  #                          (README "Spectate")
+  #   SPECTATE_TYPES         the types of it, as TYPES; defined on the connection
+  #                          that puts it (a connection's types are its own)
   #
   # and writes the rules: tick(now), public_view(now) (and spectator_view,
   # summary when they differ; spectate_view and spectate_delay_ms for what
@@ -60,6 +71,13 @@ module AsterismGames
   class Game
     SAVE_FORMAT = 1
     SAVE_HOLD_MS = 0
+    TYPES = {}.freeze
+    STATE_TYPE = nil
+    TOLD_TYPES = {}.freeze
+    SPECTATE_TYPE = nil
+    SPECTATE_TYPES = {}.freeze
+    # The namespace of the types' names (asterism-games/<game>.<what>).
+    TYPE_PREFIX = "asterism-games/"
     MAX_MEMBERS = 16
     NAME_MAX = 32
 
@@ -156,7 +174,8 @@ module AsterismGames
     end
 
     # What those who watch from outside the table see (README "Spectate"):
-    # the host puts it on asterism/<node>/spectate/<table>/state (a room's
+    # the host puts it on asterism/<node>/@shared/spectate/<table>/state
+    # (a topic of the node's shared place, of type SPECTATE_TYPE; a room's
     # table: room<slot>-<table>), a key no player's role reads and outside
     # every room, after spectate_delay_ms. It may hold what the players do
     # not see of each other (the mahjong hands), never what nobody knows