tep 0.11.4 → 0.11.5

data/lib/tep/presence.rb

@@ -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/version.rb

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

data/lib/tep.rb

@@ -70,7 +70,10 @@ require_relative "tep/live_view"
 require_relative "tep/server"
 require_relative "tep/server_scheduled"
 require_relative "tep/sqlite"
-require_relative "tep/pg"
+# tep/pg is OPT-IN (#216): NOT required here. An app that needs
+# PostgreSQL does `require "tep/pg"`, which bin/tep splices in at build
+# time (and the test suite requires explicitly). Keeping it out of the
+# core require tree is what lets a non-PG app DCE the libpq closure.
 require_relative "spinel_kit/json"
 require_relative "spinel_kit/json_decoder"
 require_relative "tep/mcp"
@@ -213,13 +216,7 @@ module Tep
   APP.set_after(Filter.new)
   APP.set_auth_filter(Filter.new)
   APP.set_auth_bearer_secret("")
-  # Broadcast PG-backend setter seeds. enable_pg_backend reaches
-  # these via set_broadcast_pg_conn / _channel / _enabled when a
-  # connect succeeds; the empty-conninfo seed below short-circuits
-  # before getting there, so we exercise the setters directly.
-  APP.set_broadcast_pg_enabled(0)
-  APP.set_broadcast_pg_channel("")
-  APP.set_broadcast_pg_conn(PG::Connection.new(""))
+  # (broadcast_pg setter seeds relocated to lib/tep/pg.rb -- #216)
   APP.set_not_found(Handler.new)
   # Type-seeding: methods that may not be called by a given user app
   # would otherwise default their param C types to mrb_int and
@@ -275,19 +272,10 @@ module Tep
   Tep::Broadcast.subscriber_count
   Tep::Broadcast.clear
 
-  # Broadcast PG-backend seeds. enable_pg_backend("", "") tries to
-  # open a PG connection -- empty conninfo behaves the same as the
-  # PG::Connection.new("") seed above: connect fails, returns -1.
-  # The point is to pin parameter types on every cmeth.
-  Tep::Broadcast.enable_pg_backend("", "")
-  Tep::Broadcast.poll_pg_once(0)
-  Tep::Broadcast.disable_pg_backend
-  Tep::Broadcast.encode_wire("", "")
-  Tep::Broadcast.deliver_wire_local("0:")
   Tep::Broadcast.publish_local_only("_seed", "")
-  # The new PG::Connection LISTEN/NOTIFY method seeds live further
-  # down with the rest of the PG seeds, where _tep_seed_pg_conn is
-  # already defined.
+  # (Broadcast PG-backend seeds -- enable_pg_backend / poll_pg_once /
+  # disable_pg_backend / encode_wire / deliver_wire_local -- relocated
+  # to lib/tep/pg.rb, #216.)
 
   # Presence type-seeding. Same pattern as Broadcast: pin every
   # cmeth's param C types so compile units that don't otherwise
@@ -317,25 +305,10 @@ module Tep
   Tep::Presence.encode_diff("join", _tep_seed_presence_entry)
   Tep::Presence.publish_diff("join", _tep_seed_presence_entry)
   Tep::Presence.sweep_expired_status
-  # PG mirror seeds (chunk 3.3). enable_pg_mirror("") fails the
-  # connect cleanly (-1) but still pins param types.
-  Tep::Presence.enable_pg_mirror("")
-  Tep::Presence.schema_sql
-  Tep::Presence.mirror_insert(_tep_seed_presence_entry)
-  Tep::Presence.mirror_delete("_seed", -1)
-  Tep::Presence.mirror_status("_seed", -1, :available, "", 0)
-  Tep::Presence.list_global("_seed")
-  Tep::Presence.count_global("_seed")
-  Tep::Presence.worker_schema_sql
-  Tep::Presence.heartbeat
-  Tep::Presence.prune_stale_workers(90)
-  Tep::Presence.disable_pg_mirror
-  # Same APP-setter-via-constant pattern as the broadcast_pg_conn
-  # seed: PG::Connection.new can't run inside App#initialize
-  # (Tep::APP is mid-construction; sched_current read segfaults).
-  APP.set_presence_pg_enabled(0)
-  APP.set_presence_pg_worker_id("")
-  APP.set_presence_pg_conn(PG::Connection.new(""))
+  # (Presence PG mirror seeds + presence_pg setter seeds relocated to
+  # lib/tep/pg.rb -- #216. The core mirror_insert/delete/status no-op
+  # stubs are already seeded by the track/set_status/untrack calls
+  # above.)
 
   # LiveView type-seeding (chunk 4.1). The render_page + dispatch_event
   # cmeths get pinned via top-level calls; the base-class mount /
@@ -387,72 +360,9 @@ module Tep
     _tep_seed_db.close
   end
 
-  # PG type-seeding. PG::Connection.new("") returns a connection-
-  # failed instance (@pgh=-1) rather than raising, so this is safe
-  # at module load regardless of whether libpq has a reachable
-  # server. The point is to pin parameter / return types on every
-  # public Connection / Result method so apps that don't exercise
-  # one method still compile cleanly.
-  _tep_seed_pg_conn = PG::Connection.new("")
-  _tep_seed_pg_conn.connected?
-  _tep_seed_pg_conn.status
-  _tep_seed_pg_conn.transaction_status
-  _tep_seed_pg_conn.server_version
-  _tep_seed_pg_conn.error_message
-  _tep_seed_pg_conn.escape_string("")
-  _tep_seed_pg_conn.escape_identifier("")
-  _tep_seed_pg_conn.escape_literal("")
-  _tep_seed_pg_conn.last_sqlstate = ""
-  _tep_seed_pg_conn.last_error_message = ""
-  _tep_seed_pg_conn.last_result_rh = -1
-  # Async surface seed -- calling these on a failed-conn instance
-  # is harmless (the C shim short-circuits on conn slot < 1).
-  _tep_seed_pg_conn.async_exec("")
-  _tep_seed_pg_seed_arr = [""]
-  _tep_seed_pg_seed_arr.delete_at(0)
-  _tep_seed_pg_conn.async_exec_params("", _tep_seed_pg_seed_arr)
-  # Async connect cmeth. Returns -1 for empty conninfo from a
-  # non-scheduled context (the shim's PQconnectStart-then-FAILED
-  # path), which is type-equivalent to the success path.
-  PG::Connection.async_connect("")
-  # LISTEN / NOTIFY surface (Tep::Broadcast PG backend lands here).
-  _tep_seed_pg_conn.listen("_seed")
-  _tep_seed_pg_conn.unlisten("_seed")
-  _tep_seed_pg_conn.notify("_seed", "")
-  _tep_seed_pg_conn.poll_notification(0)
-  _tep_seed_pg_conn.last_notify_channel
-  _tep_seed_pg_conn.last_notify_payload
-  _tep_seed_pg_res = PG::Result.new(-1)
-  _tep_seed_pg_res.ntuples
-  _tep_seed_pg_res.nfields
-  _tep_seed_pg_res.fname(0)
-  _tep_seed_pg_res.fnumber("")
-  _tep_seed_pg_res.ftype(0)
-  _tep_seed_pg_res.fformat(0)
-  _tep_seed_pg_res.fmod(0)
-  _tep_seed_pg_res.getvalue(0, 0)
-  _tep_seed_pg_res.getisnull(0, 0)
-  _tep_seed_pg_res.getlength(0, 0)
-  _tep_seed_pg_res.value(0, 0)
-  _tep_seed_pg_res.error_field(67)
-  _tep_seed_pg_res.cmd_status
-  _tep_seed_pg_res.cmd_tuples
-  _tep_seed_pg_res.error_message
-  _tep_seed_pg_res.sql_state
-  _tep_seed_pg_res.fields
-  _tep_seed_pg_res.values
-  _tep_seed_pg_res.column_values(0)
-  _tep_seed_pg_res.clear
-  _tep_seed_pg_conn.close
-  # Pool seed -- size 0 so we don't try to open real conns at load.
-  _tep_seed_pg_pool = PG::Pool.new("", 0)
-  _tep_seed_pg_pool.healthy?
-  _tep_seed_pg_pool.available
-  _tep_seed_pg_pool.size
-  _tep_seed_pg_pool.set_checkout_timeout_ms(0)
-  _tep_seed_pg_pool.close_all
-  # NB: don't checkout/checkin against the size-0 seed pool; it'd
-  # spin until timeout. The seed has @free.length=0 forever.
+  # (PG::Connection / Result / Pool type-seeding relocated to
+  # lib/tep/pg.rb -- #216. PG.Connection.new("") is a failed-conn
+  # instance, not a raise, so the seeds stay safe at module load.)
 
   # SpinelKit::Json type-seeding. Pin every public method's parameter
   # types so an app that uses one method but not another still
@@ -539,10 +449,19 @@ module Tep
   Tep::Scheduler.clear
 
   # Tep::Shell seed -- pin :str args at the FFI boundary.
+  #
+  # These run at MODULE LOAD, so the paths must be readable in EVERY
+  # deploy environment, not just gx10. `/etc/hostname` is absent in a
+  # bare container (e.g. Upsun); under the engine's now-correct
+  # ENOENT-raising File.read it threw at boot and 502'd the native
+  # serve_bin (tep#199 boot-hazard report). `/dev/null` exists on every
+  # POSIX target (Linux containers, macOS) and reads as empty, so it
+  # pins the same :str param type without the missing-file crash. The
+  # full fix -- no boot-time seed I/O at all -- is tep#199 (--rbs sig).
   Tep::Shell.run(":")
   Tep::Shell.run_limited(":", 1)
-  Tep::Shell.read("/etc/hostname")
-  Tep::Shell.read_limited("/etc/hostname", 64)
+  Tep::Shell.read("/dev/null")
+  Tep::Shell.read_limited("/dev/null", 64)
 
   # SpinelKit::Url seed -- the new split_url has to land at compile time.
   SpinelKit::Url.split_url("http://x/")

data/spinel-ext.json

@@ -5,6 +5,12 @@
     "source": "lib/tep/sphttp.c",
     "cflags": ["-O2"]
   },
+  {
+    "name": "sphttp",
+    "placeholder": "@TEP_SPHTTP_CFLAGS@",
+    "pkg_config": "openssl",
+    "pkg_config_fallback": "-lssl -lcrypto"
+  },
   {
     "name": "sqlite",
     "placeholder": "@TEP_SQLITE_O@",

data/test/test_broadcast_pg.rb

@@ -18,6 +18,7 @@ class TestBroadcastPg < TepTest
 
   app_source <<~RB
     require 'sinatra'
+    require "tep/pg"          # opt-in PG backend (#216)
 
     PG_URL  = "#{PG_URL}"
     CHANNEL = "#{CHANNEL}"

data/test/test_pg.rb

@@ -42,6 +42,7 @@ class TestPg < TepTest
   # in the compiled binary.
   app_source <<~RB
     require 'sinatra'
+    require "tep/pg"          # opt-in PG backend (#216)
 
     # The PG test app runs under the default prefork server. We
     # exercise the async surface explicitly via /async_exec and

data/test/test_presence_pg.rb

@@ -29,6 +29,7 @@ class TestPresencePg < TepTest
 
   app_source <<~RB
     require 'sinatra'
+    require "tep/pg"          # opt-in PG backend (#216)
 
     PG_URL = "#{PG_URL}"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tep
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 0.11.5
 platform: ruby
 authors:
 - Ori Pekelman
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: spinel_kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: |-
   tep is a small Sinatra-style DSL targeting the Spinel AOT Ruby
   compiler. The translator turns a Sinatra-classic source file into