tep 0.11.3 → 0.11.5

data/lib/tep/presence.rb

@@ -211,21 +211,21 @@ module Tep
     end
 
     # Flat-JSON wire format for a diff event. `kind` is one of
-    # "join" / "leave" / "status". Tep::Json's flat-object
+    # "join" / "leave" / "status". SpinelKit::Json's flat-object
     # extractors handle this on the client side (or any
     # JSON-aware peer).
     def self.encode_diff(kind, entry)
       "{" +
-        Tep::Json.encode_pair_str("kind", kind) + "," +
-        Tep::Json.encode_pair_str("topic", entry.topic) + "," +
-        Tep::Json.encode_pair_str("principal", entry.principal_id) + "," +
-        Tep::Json.encode_pair_str("ekind", entry.kind.to_s) + "," +
-        Tep::Json.encode_pair_str("agent_id", entry.agent_id) + "," +
-        Tep::Json.encode_pair_int("fd", entry.fd) + "," +
-        Tep::Json.encode_pair_int("since", entry.since) + "," +
-        Tep::Json.encode_pair_str("state", entry.status_state.to_s) + "," +
-        Tep::Json.encode_pair_str("note", entry.status_note) + "," +
-        Tep::Json.encode_pair_int("until_ts", entry.status_until) +
+        SpinelKit::Json.encode_pair_str("kind", kind) + "," +
+        SpinelKit::Json.encode_pair_str("topic", entry.topic) + "," +
+        SpinelKit::Json.encode_pair_str("principal", entry.principal_id) + "," +
+        SpinelKit::Json.encode_pair_str("ekind", entry.kind.to_s) + "," +
+        SpinelKit::Json.encode_pair_str("agent_id", entry.agent_id) + "," +
+        SpinelKit::Json.encode_pair_int("fd", entry.fd) + "," +
+        SpinelKit::Json.encode_pair_int("since", entry.since) + "," +
+        SpinelKit::Json.encode_pair_str("state", entry.status_state.to_s) + "," +
+        SpinelKit::Json.encode_pair_str("note", entry.status_note) + "," +
+        SpinelKit::Json.encode_pair_int("until_ts", entry.status_until) +
       "}"
     end
 
@@ -265,325 +265,29 @@ module Tep
       swept
     end
 
-    # ---- PG mirror (cross-worker visibility) ----
-    #
-    # Opt-in mirror of the local presence registry to a shared PG
-    # table. Each worker's track/untrack/set_status writes also
-    # touch the table; list_global / count_global read across all
-    # workers. The local registry stays the fast read path for
-    # per-worker queries (list / count); list_global is for the
-    # "who's globally in this room" snapshot that's typically a
-    # one-shot UI render.
-    #
-    # Worker ID is PID + boot epoch second so a same-PID restart
-    # doesn't alias a prior worker's stale rows. On
-    # disable_pg_mirror (or clean shutdown), this worker's rows
-    # get DELETE'd. Crashed workers leave stale rows; the
-    # heartbeat + prune_stale_workers pair below handles the
-    # garbage-collection.
-    #
-    # Returns 0 on success, -1 on connect / schema failure.
-    def self.enable_pg_mirror(conninfo)
-      conn = PG::Connection.new(conninfo)
-      if conn.pgh < 0
-        return -1
-      end
-      # exec raises PG::Error on failure now; degrade gracefully
-      # (close + return -1) rather than letting it escape the worker.
-      begin
-        r = conn.exec(Tep::Presence.schema_sql)
-        r.clear
-        # Heartbeat table for the prune-stale-workers path (#47).
-        r = conn.exec(Tep::Presence.worker_schema_sql)
-        r.clear
-      rescue PG::Error
-        conn.finish
-        return -1
-      end
-      Tep::APP.set_presence_pg_conn(conn)
-      worker_id = Sock.sphttp_getpid.to_s + "-" + Time.now.to_i.to_s
-      Tep::APP.set_presence_pg_worker_id(worker_id)
-      Tep::APP.set_presence_pg_enabled(1)
-      # Drop any rows from a prior worker that managed to leave
-      # stale entries with this same worker_id (unlikely thanks
-      # to the boot-epoch suffix, but defensive). Best-effort.
-      Tep::Presence.mirror_exec(
-        "DELETE FROM tep_presence WHERE worker_id = $1",
-        [worker_id])
-      # Register this worker's heartbeat row immediately. Apps
-      # refresh it periodically via Tep::Presence.heartbeat;
-      # prune_stale_workers deletes rows whose heartbeat is stale.
-      Tep::Presence.heartbeat
-      0
-    end
-
-    def self.disable_pg_mirror
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      # Best-effort cleanup -- swallow PG errors (we're tearing the
-      # mirror down regardless) and still finish + disable below.
-      begin
-        r = Tep::APP.presence_pg_conn.exec_params(
-          "DELETE FROM tep_presence WHERE worker_id = $1",
-          [Tep::APP.presence_pg_worker_id])
-        r.clear
-        # Remove the heartbeat row so prune_stale_workers doesn't
-        # see this worker as live after we're gone.
-        r = Tep::APP.presence_pg_conn.exec_params(
-          "DELETE FROM tep_presence_worker WHERE worker_id = $1",
-          [Tep::APP.presence_pg_worker_id])
-        r.clear
-      rescue PG::Error
-        # swallow -- shutting the mirror down anyway
-      end
-      Tep::APP.presence_pg_conn.finish
-      Tep::APP.set_presence_pg_enabled(0)
-      0
-    end
-
-    # CREATE TABLE statement, kept here so apps that want to
-    # provision the schema separately (migration runners, etc.)
-    # can grab the canonical DDL. Idempotent via IF NOT EXISTS.
-    def self.schema_sql
-      "CREATE TABLE IF NOT EXISTS tep_presence (" +
-        "worker_id    TEXT NOT NULL, " +
-        "topic        TEXT NOT NULL, " +
-        "fd           INTEGER NOT NULL, " +
-        "principal_id TEXT NOT NULL, " +
-        "kind         TEXT NOT NULL, " +
-        "agent_id     TEXT NOT NULL, " +
-        "since_ts     BIGINT NOT NULL, " +
-        "status_state TEXT NOT NULL, " +
-        "status_note  TEXT NOT NULL, " +
-        "status_until BIGINT NOT NULL, " +
-        "PRIMARY KEY (worker_id, topic, fd)" +
-      ")"
-    end
-
-    # Heartbeat table -- one row per worker that's mirroring
-    # presence right now. Used by prune_stale_workers to identify
-    # crashed workers (no heartbeat updates in N seconds) and
-    # garbage-collect their orphan tep_presence rows.
-    def self.worker_schema_sql
-      "CREATE TABLE IF NOT EXISTS tep_presence_worker (" +
-        "worker_id    TEXT PRIMARY KEY, " +
-        "last_seen_ts BIGINT NOT NULL" +
-      ")"
-    end
-
-    # Refresh this worker's heartbeat row to the current Unix
-    # timestamp. Apps call this periodically (typical: from a
-    # before-filter, a Tep::Job tick, or an explicit timer fiber)
-    # so prune_stale_workers can tell live workers from crashed
-    # ones. No-op when the PG mirror isn't enabled, or when the
-    # mirror was opened on a different process and we're the
-    # post-fork child (worker_id is empty until enable_pg_mirror
-    # runs locally).
-    #
-    # Returns 1 if the heartbeat row was upserted, 0 if the call
-    # short-circuited (mirror disabled or no worker_id).
-    def self.heartbeat
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      wid = Tep::APP.presence_pg_worker_id
-      if wid.length == 0
-        return 0
-      end
-      begin
-        r = Tep::APP.presence_pg_conn.exec_params(
-          "INSERT INTO tep_presence_worker (worker_id, last_seen_ts) " +
-          "VALUES ($1, $2) " +
-          "ON CONFLICT (worker_id) DO UPDATE SET " +
-          "  last_seen_ts = EXCLUDED.last_seen_ts",
-          [wid, Time.now.to_i.to_s])
-        r.clear
-      rescue PG::Error
-        return 0
-      end
-      1
-    end
-
-    # Prune crashed-worker rows. Deletes:
-    #   1. tep_presence_worker rows whose last_seen_ts is older than
-    #      ttl_seconds (the worker's heartbeat is stale).
-    #   2. tep_presence rows whose worker_id has no surviving
-    #      heartbeat (orphans left by the crashed worker).
-    #
-    # Apps call this periodically -- the canonical shape is a
-    # before-filter on a "/health" route that internal monitoring
-    # hits every 30s, or a Tep::Job that fires from a cron-like
-    # tick. Returns the number of tep_presence rows deleted.
-    #
-    # ttl_seconds should be at least 3x the app's typical
-    # heartbeat interval so a transient slow response doesn't
-    # evict a live worker. Default callers pass 90 (assumes 30s
-    # heartbeats).
-    def self.prune_stale_workers(ttl_seconds)
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      cutoff = Time.now.to_i - ttl_seconds
-      conn = Tep::APP.presence_pg_conn
-      begin
-        # Drop dead heartbeats first; the second DELETE then walks
-        # the worker_id space that's still alive.
-        r1 = conn.exec_params(
-          "DELETE FROM tep_presence_worker WHERE last_seen_ts < $1",
-          [cutoff.to_s])
-        r1.clear
-        # Now drop presence rows whose worker_id isn't in the live
-        # heartbeat table. NOT IN handles both crashed-and-pruned
-        # workers and workers that never registered (legacy rows
-        # from before this prune feature shipped).
-        r2 = conn.exec(
-          "DELETE FROM tep_presence " +
-          "WHERE worker_id NOT IN (SELECT worker_id FROM tep_presence_worker)")
-        n = r2.cmd_tuples
-        r2.clear
-      rescue PG::Error
-        return 0
-      end
-      n
-    end
-
-    # Best-effort mirror write: run an exec_params on the mirror conn
-    # and swallow any PG::Error. The PG mirror is advisory -- local
-    # presence is authoritative -- so a transient mirror failure must
-    # never propagate into the caller's request now that exec raises
-    # (matz/spinel#627 + #1041). Always returns 0.
-    def self.mirror_exec(sql, params)
-      begin
-        r = Tep::APP.presence_pg_conn.exec_params(sql, params)
-        r.clear
-      rescue PG::Error
-        # swallow -- advisory mirror, local presence is authoritative
-      end
-      0
-    end
-
-    # Mirror a track to PG. Called from track() when the PG
-    # mirror is enabled.
-    def self.mirror_insert(entry)
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      Tep::Presence.mirror_exec(
-        "INSERT INTO tep_presence " +
-        "(worker_id, topic, fd, principal_id, kind, agent_id, " +
-        " since_ts, status_state, status_note, status_until) " +
-        "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) " +
-        "ON CONFLICT (worker_id, topic, fd) DO UPDATE SET " +
-        "  principal_id = EXCLUDED.principal_id, " +
-        "  kind         = EXCLUDED.kind, " +
-        "  agent_id     = EXCLUDED.agent_id, " +
-        "  since_ts     = EXCLUDED.since_ts, " +
-        "  status_state = EXCLUDED.status_state, " +
-        "  status_note  = EXCLUDED.status_note, " +
-        "  status_until = EXCLUDED.status_until",
-        [
-          Tep::APP.presence_pg_worker_id,
-          entry.topic,
-          entry.fd.to_s,
-          entry.principal_id,
-          entry.kind.to_s,
-          entry.agent_id,
-          entry.since.to_s,
-          entry.status_state.to_s,
-          entry.status_note,
-          entry.status_until.to_s
-        ])
-    end
-
-    # Mirror an untrack to PG.
-    def self.mirror_delete(topic, fd)
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      Tep::Presence.mirror_exec(
-        "DELETE FROM tep_presence " +
-        "WHERE worker_id = $1 AND topic = $2 AND fd = $3",
-        [Tep::APP.presence_pg_worker_id, topic, fd.to_s])
-    end
-
-    # Mirror a status update.
-    def self.mirror_status(topic, fd, state, note, until_ts)
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      Tep::Presence.mirror_exec(
-        "UPDATE tep_presence " +
-        "SET status_state = $4, status_note = $5, status_until = $6 " +
-        "WHERE worker_id = $1 AND topic = $2 AND fd = $3",
-        [Tep::APP.presence_pg_worker_id, topic, fd.to_s,
-         state.to_s, note, until_ts.to_s])
-    end
+# ---- PG mirror (cross-worker visibility) ----
+#
+# The presence PG mirror is OPT-IN (#216). enable_pg_mirror /
+# disable_pg_mirror / heartbeat / prune_stale_workers / mirror_exec /
+# list_global / count_global / the schema DDL, and the REAL bodies of
+# the mirror_* hooks below, live in lib/tep/pg.rb and only compile
+# into apps that `require "tep/pg"`. Core Presence keeps no PG
+# reference, so a non-PG app DCEs the libpq closure entirely.
+#
+# track / untrack / set_status call these mirror_* hooks
+# unconditionally; the core definitions are no-ops. `require
+# "tep/pg"` redefines them (last-definition-wins) with the real
+# exec_params writes.
+def self.mirror_insert(entry)
+  0
+end
 
-    # Cross-worker list: SELECT all entries on `topic` regardless
-    # of which worker tracked them. Returns Array[PresenceEntry]
-    # built from the PG rows. The returned entries are read-only
-    # snapshots -- mutating them doesn't write back to PG.
-    def self.list_global(topic)
-      result = [Tep::PresenceEntry.new("", "", :human, "", -1, 0)]
-      result.delete_at(0)
-      if Tep::APP.presence_pg_enabled == 0
-        return result
-      end
-      begin
-        r = Tep::APP.presence_pg_conn.exec_params(
-          "SELECT principal_id, kind, agent_id, fd, since_ts, " +
-          "       status_state, status_note, status_until " +
-          "FROM tep_presence WHERE topic = $1 ORDER BY since_ts",
-          [topic])
-      rescue PG::Error
-        return result
-      end
-      i = 0
-      n = r.ntuples
-      while i < n
-        kind_sym = :human
-        if r.getvalue(i, 1) == "agent_for"
-          kind_sym = :agent_for
-        end
-        state_sym = :available
-        sstr = r.getvalue(i, 5)
-        if sstr == "busy"
-          state_sym = :busy
-        elsif sstr == "blocked"
-          state_sym = :blocked
-        end
-        e = Tep::PresenceEntry.new(
-          topic,
-          r.getvalue(i, 0),
-          kind_sym,
-          r.getvalue(i, 2),
-          r.getvalue(i, 3).to_i,
-          r.getvalue(i, 4).to_i)
-        e.status_state = state_sym
-        e.status_note  = r.getvalue(i, 6)
-        e.status_until = r.getvalue(i, 7).to_i
-        result.push(e)
-        i += 1
-      end
-      r.clear
-      result
-    end
+def self.mirror_delete(topic, fd)
+  0
+end
 
-    def self.count_global(topic)
-      if Tep::APP.presence_pg_enabled == 0
-        return 0
-      end
-      begin
-        r = Tep::APP.presence_pg_conn.exec_params(
-          "SELECT count(*) FROM tep_presence WHERE topic = $1",
-          [topic])
-      rescue PG::Error
-        return 0
-      end
-      n = r.getvalue(0, 0).to_i
-      r.clear
-      n
-    end
+def self.mirror_status(topic, fd, state, note, until_ts)
+  0
+end
   end
 end

data/lib/tep/proxy.rb

@@ -12,7 +12,7 @@
 #     end
 #
 #     def after_forward(req, ures, res)
-#       Tep::Logger.info("upstream " + ures.status.to_s)
+#       LOGGER.info("upstream " + ures.status.to_s)   # LOGGER = SpinelKit::Log.new
 #       0
 #     end
 #   end
@@ -246,7 +246,7 @@ module Tep
     # An LLM gateway typically overrides this as:
     #
     #   def stream_request?(req)
-    #     Tep::Json.get_bool(req.raw_body, "stream")
+    #     SpinelKit::Json.get_bool(req.raw_body, "stream")
     #   end
     def stream_request?(req)
       false
@@ -298,10 +298,10 @@ module Tep
         res.set_status(413)
         res.headers["Content-Type"] = "application/json"
         err_body = "{\"error\":{" +
-          Tep::Json.encode_pair_str("message",
+          SpinelKit::Json.encode_pair_str("message",
             "request body exceeds proxy cap of " +
             @max_request_body_bytes.to_s + " bytes") + "," +
-          Tep::Json.encode_pair_str("type", "payload_too_large") +
+          SpinelKit::Json.encode_pair_str("type", "payload_too_large") +
         "}}"
         res.set_body(err_body)
         return err_body
@@ -378,10 +378,10 @@ module Tep
         res.set_status(502)
         res.headers["Content-Type"] = "application/json"
         err_body = "{\"error\":{" +
-          Tep::Json.encode_pair_str("message",
+          SpinelKit::Json.encode_pair_str("message",
             "upstream response body exceeds proxy cap of " +
             @max_response_body_bytes.to_s + " bytes") + "," +
-          Tep::Json.encode_pair_str("type", "upstream_body_too_large") +
+          SpinelKit::Json.encode_pair_str("type", "upstream_body_too_large") +
         "}}"
         res.set_body(err_body)
         return err_body
@@ -424,7 +424,7 @@ module Tep
     # 502 and returns "" without starting a stream.
     def start_streaming_forward(req, res, ureq)
       url   = pick_upstream(req) + ureq.path
-      parts = Tep::Url.split_url(url)
+      parts = SpinelKit::Url.split_url(url)
       if parts["scheme"] != "http"
         res.set_status(502)
         return ""

data/lib/tep/request.rb

@@ -180,7 +180,7 @@ module Tep
     # @raw_body to Content-Length.
     def parse_form_body
       if form?
-        Url.parse_query(@raw_body).each do |k, v|
+        SpinelKit::Url.parse_query(@raw_body).each do |k, v|
           @params[k] = v
         end
       elsif multipart?

data/lib/tep/response.rb

@@ -88,7 +88,7 @@ module Tep
     # (path, expires, max-age, domain, samesite, httponly, secure).
     # Empty `opts` is fine: just writes "name=value".
     def set_cookie(name, value, opts)
-      line = name + "=" + Url.escape(value)
+      line = name + "=" + SpinelKit::Url.escape(value)
       if opts.length > 0
         opts.each do |k, v|
           if v.length == 0

data/lib/tep/router.rb

@@ -77,7 +77,7 @@ module Tep
         pp = pat[i]
         if pp.length > 0 && pp[0] == ":"
           name = @r_params[pi]
-          req.params[name] = Url.unescape(rp[i])
+          req.params[name] = SpinelKit::Url.unescape(rp[i])
           pi += 1
         end
         i += 1

data/lib/tep/session.rb

@@ -46,7 +46,7 @@ module Tep
       if !Tep.timing_safe_eq(sig, expect)
         return false
       end
-      Url.parse_query(payload).each do |k, v|
+      SpinelKit::Url.parse_query(payload).each do |k, v|
         @data[k] = v
       end
       true
@@ -61,7 +61,7 @@ module Tep
         if !first
           payload = payload + "&"
         end
-        payload = payload + Url.escape(k) + "=" + Url.escape(v)
+        payload = payload + SpinelKit::Url.escape(k) + "=" + SpinelKit::Url.escape(v)
         first = false
       end
       payload + "." + Crypto.sp_crypto_hmac_sha256_hex(secret, payload)

data/lib/tep/version.rb

@@ -1,3 +1,3 @@
 module Tep
-  VERSION = "0.11.3"
+  VERSION = "0.11.5"
 end