pg-replication-protocol 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07bd494baf2df079a175855749b79dc41460c5903a58e3cef89f7ac1304e6e9b
-  data.tar.gz: 28ad5dced1a6a73c84a62ce6eae434dbde34883378555c8bac7674d477928627
+  metadata.gz: fc030b9fec7b0a01acbf309813046913b36da4ddc289e7201d17e78b6de0d471
+  data.tar.gz: 7fa53e2ce183c315b70812f1d58af99afa492419d208704f2cbf97d67a7e57f8
 SHA512:
-  metadata.gz: 7bd50c203eb711090bdbb0b16d745e46472d936191ac3c3653138bc9db42cecd6b1ed51a625eeae5194be3ca17c66e6f8a05dd4a860979a791d4fa54eee74139
-  data.tar.gz: 3ddaf038c9cdfab3c05c4ac2e6eac8c1799c7a0b1d334a4657b19a9251feeac835784bbdec5a94fba43260f50b932441cd49786f1f573c7a607687a742ef8eb4
+  metadata.gz: 2a9ab36b64b600bbd3f306d818f2bfc06666e520bba5588614ed5783c78227b1277522f03737de90b185ef659bd099cbb4064ece4d2afbafe5e8815e71916ca8
+  data.tar.gz: a94a6ca7fddac35799d4dad64099aacc0af68b4d7e37ffcd777d504852a29f26016595d3e5a15c3a3a9174a9706709787342f80fb059e4a01292d00f219e8df6

data/Gemfile

@@ -5,6 +5,8 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
+gem "base64"
+gem "rbs"
 
 group :test do
   gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -1,20 +1,24 @@
 PATH
   remote: .
   specs:
-    pg-replication-protocol (0.0.5)
+    pg-replication-protocol (0.0.7)
       pg (~> 1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    base64 (0.3.0)
     diff-lcs (1.5.1)
     docker-api (2.4.0)
       excon (>= 0.64.0)
       multi_json
     excon (1.2.1)
+    logger (1.7.0)
     multi_json (1.15.0)
     pg (1.5.9)
     rake (13.2.1)
+    rbs (3.9.4)
+      logger
     rspec (3.13.0)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
@@ -38,8 +42,10 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  base64
   pg-replication-protocol!
   rake (~> 13.0)
+  rbs
   rspec (~> 3.0)
   testcontainers-postgres
 

data/Rakefile

@@ -2,3 +2,7 @@
 
 require "bundler/gem_tasks"
 task default: %i[]
+
+task :test do
+  sh "bundle exec rbs test --target PG::Replication::* bundle exec rspec"
+end

data/lib/pg/replication/buffer.rb

@@ -19,19 +19,19 @@ module PG
       end
 
       def read_int8
-        read(1).unpack("C").first
+        readbyte
       end
 
       def read_int16
-        read(2).unpack("n").first
+        read_bytes(2).unpack("n").first
       end
 
       def read_int32
-        read(4).unpack("N").first
+        read_bytes(4).unpack("N").first
       end
 
       def read_int64
-        read(8).unpack("Q>").first
+        read_bytes(8).unpack("Q>").first
       end
 
       def read_timestamp
@@ -50,6 +50,14 @@ module PG
           end
         end
       end
+
+      private
+
+      def read_bytes(n)
+        bytes = read(n)
+        raise EOFError if bytes.nil? || bytes.size < n
+        bytes
+      end
     end
   end
 end

data/lib/pg/replication/pg_output.rb

@@ -13,7 +13,19 @@ module PG
       Update = Data.define(:oid, :key, :old, :new)
       Delete = Data.define(:oid, :key, :old)
       Truncate = Data.define(:oid)
-      Tuple = Data.define(:type, :data)
+      Tuple = Data.define(:type, :data) do
+        def text?
+          type == "t"
+        end
+
+        def binary?
+          type == "b"
+        end
+
+        def toast?
+          type == "u"
+        end
+      end
       Column = Data.define(:flags, :name, :oid, :modifier) do
         def key?
           flags == 1
@@ -150,8 +162,10 @@ module PG
       end
 
       def self.read_tuple(buffer)
-        case buffer.read_char
-        in type if type == "n"
+        case (type = buffer.read_char)
+        in "n"
+          Tuple.new(type:, data: nil)
+        in "u"
           Tuple.new(type:, data: nil)
         in type
           size = buffer.read_int32

data/lib/pg/replication/version.rb

@@ -2,6 +2,6 @@
 
 module PG
   module Replication
-    VERSION = "0.0.5"
+    VERSION = "0.0.7"
   end
 end

data/lib/pg/replication.rb

@@ -48,15 +48,18 @@ module PG
               case (msg = Protocol.read_message(Buffer.new(StringIO.new(data))))
               in Protocol::XLogData(lsn:, data:) if auto_keep_alive
                 y << msg
-                standby_status_update(write_lsn: lsn)
-                @last_confirmed_lsn = lsn
+                standby_status_update(write_lsn: lsn) if lsn > 0
                 last_keep_alive = Time.now
 
-              in Protocol::PrimaryKeepalive(server_time:, asap: true) if auto_keep_alive
-                standby_status_update(write_lsn: @last_confirmed_lsn)
+              in Protocol::PrimaryKeepalive(current_lsn:, server_time:, asap: true) if auto_keep_alive
+                standby_status_update(write_lsn: current_lsn)
                 last_keep_alive = Time.now
                 y << msg
 
+              in Protocol::PrimaryKeepalive(current_lsn:)
+                y << msg
+                @last_confirmed_lsn = [@last_confirmed_lsn, current_lsn].compact.max
+
               else
                 y << msg
               end

data/sig/pg/replication.rbs

@@ -0,0 +1,283 @@
+module PG
+  module Replication
+    module Protocol
+      class PrimaryKeepalive < ::Data
+        def self.new: (Integer current_lsn, Time server_time, Boolean asap) -> instance
+                    | (current_lsn: Integer, server_time: Time, asap: Boolean) -> instance
+
+        def self.[]: (Integer current_lsn, Time server_time, Boolean asap) -> instance
+                   | (current_lsn: Integer, server_time: Time, asap: Boolean) -> instance
+
+        def self.members: () -> [ :current_lsn, :server_time, :asap ]
+
+        def members: () -> [ :current_lsn, :server_time, :asap ]
+
+        attr_reader current_lsn: Integer
+
+        attr_reader server_time: Time
+
+        attr_reader asap: Boolean
+      end
+
+      class XLogData[T] < ::Data
+        def self.new: (Integer lsn, Integer current_lsn, Time server_time, T data) -> instance
+                    | (lsn: Integer, current_lsn: Integer, server_time: Time, data: T) -> instance
+
+        def self.[]: (Integer lsn, Integer current_lsn, Time server_time, T data) -> instance
+                   | (lsn: Integer, current_lsn: Integer, server_time: Time, data: T) -> instance
+
+        def self.members: () -> [ :lsn, :current_lsn, :server_time, :data ]
+
+        def members: () -> [ :lsn, :current_lsn, :server_time, :data ]
+
+        attr_reader lsn: Integer
+
+        attr_reader current_lsn: Integer
+
+        attr_reader server_time: Time
+
+        attr_reader data: T
+      end
+    end
+
+    module PGOutput
+      class Begin < ::Data
+        def self.new: (Integer final_lsn, Time timestamp, Integer xid) -> instance
+                    | (final_lsn: Integer, timestamp: Time, xid: Integer) -> instance
+
+        def self.[]: (Integer final_lsn, Time timestamp, Integer xid) -> instance
+                   | (final_lsn: Integer, timestamp: Time, xid: Integer) -> instance
+
+        def self.members: () -> [ :final_lsn, :timestamp, :xid ]
+
+        def members: () -> [ :final_lsn, :timestamp, :xid ]
+
+        attr_reader final_lsn: Integer
+
+        attr_reader timestamp: Time
+
+        attr_reader xid: Integer
+      end
+
+      class Column < ::Data
+        def self.new: (Integer flags, String name, Integer oid, Integer modifier) -> instance
+                    | (flags: Integer, name: String, oid: Integer, modifier: Integer) -> instance
+
+        def self.[]: (Integer flags, String name, Integer oid, Integer modifier) -> instance
+                   | (flags: Integer, name: String, oid: Integer, modifier: Integer) -> instance
+
+        def self.members: () -> [ :flags, :name, :oid, :modifier ]
+
+        def members: () -> [ :flags, :name, :oid, :modifier ]
+
+        attr_reader flags: Integer
+
+        attr_reader name: String
+
+        attr_reader oid: Integer
+
+        attr_reader modifier: Integer
+
+        def key?: () -> Boolean
+      end
+
+      class Commit < ::Data
+        def self.new: (Integer lsn, Integer end_lsn, Time timestamp) -> instance
+                    | (lsn: Integer, end_lsn: Integer, timestamp: Time) -> instance
+
+        def self.[]: (Integer lsn, Integer end_lsn, Time timestamp) -> instance
+                   | (lsn: Integer, end_lsn: Integer, timestamp: Time) -> instance
+
+        def self.members: () -> [ :lsn, :end_lsn, :timestamp ]
+
+        def members: () -> [ :lsn, :end_lsn, :timestamp ]
+
+        attr_reader lsn: Integer
+
+        attr_reader end_lsn: Integer
+
+        attr_reader timestamp: Time
+      end
+
+      class Delete < ::Data
+        def self.new: (Integer oid, Array[String] key, Array[String] old) -> instance
+                    | (oid: Integer, key: Array[String], old: Array[String]) -> instance
+
+        def self.[]: (Integer oid, Array[String] key, Array[String] old) -> instance
+                   | (oid: Integer, key: Array[String], old: Array[String]) -> instance
+
+        def self.members: () -> [ :oid, :key, :old ]
+
+        def members: () -> [ :oid, :key, :old ]
+
+        attr_reader oid: Integer
+
+        attr_reader key: Array[String]
+
+        attr_reader old: Array[String]
+      end
+
+      class Insert < ::Data
+        def self.new: (Integer oid, Array[String] new) -> instance
+                    | (oid: Integer, new: Array[String]) -> instance
+
+        def self.[]: (Integer oid, Array[String] new) -> instance
+                   | (oid: Integer, new: Array[String]) -> instance
+
+        def self.members: () -> [ :oid, :new ]
+
+        def members: () -> [ :oid, :new ]
+
+        attr_reader oid: Integer
+
+        attr_reader new: Array[String]
+      end
+
+      class Message < ::Data
+        def self.new: (Boolean transactional, Integer lsn, String? prefix, String? content) -> instance
+                    | (transactional: Boolean, lsn: Integer, prefix: String?, content: String?) -> instance
+
+        def self.[]: (Boolean transactional, Integer lsn, String? prefix, String? content) -> instance
+                   | (transactional: Boolean, lsn: Integer, prefix: String?, content: String?) -> instance
+
+        def self.members: () -> [ :transactional, :lsn, :prefix, :content ]
+
+        def members: () -> [ :transactional, :lsn, :prefix, :content ]
+
+        attr_reader transactional: Boolean
+
+        attr_reader lsn: Integer
+
+        attr_reader prefix: String?
+
+        attr_reader content: String?
+      end
+
+      class Origin < ::Data
+        def self.new: (Integer commit_lsn, String name) -> instance
+                    | (commit_lsn: Integer, name: String) -> instance
+
+        def self.[]: (Integer commit_lsn, String name) -> instance
+                   | (commit_lsn: Integer, name: String) -> instance
+
+        def self.members: () -> [ :commit_lsn, :name ]
+
+        def members: () -> [ :commit_lsn, :name ]
+
+        attr_reader commit_lsn: Integer
+
+        attr_reader name: String
+      end
+
+      class Relation < ::Data
+        def self.new: (Integer oid, String namespace, String name, String replica_identity, Array[PG::Replication::PGOutput::Column] columns) -> instance
+                    | (oid: Integer, namespace: String, name: String, replica_identity: String, columns: Array[PG::Replication::PGOutput::Column]) -> instance
+
+        def self.[]: (Integer oid, String namespace, String name, String replica_identity, Array[PG::Replication::PGOutput::Column] columns) -> instance
+                   | (oid: Integer, namespace: String, name: String, replica_identity: String, columns: Array[PG::Replication::PGOutput::Column]) -> instance
+
+        def self.members: () -> [ :oid, :namespace, :name, :replica_identity, :columns ]
+
+        def members: () -> [ :oid, :namespace, :name, :replica_identity, :columns ]
+
+        attr_reader oid: Integer
+
+        attr_reader namespace: String
+
+        attr_reader name: String
+
+        attr_reader replica_identity: String
+
+        attr_reader columns: Array[PG::Replication::PGOutput::Column]
+      end
+
+      class Truncate < ::Data
+        def self.new: (Integer oid) -> instance
+                    | (oid: Integer) -> instance
+
+        def self.[]: (Integer oid) -> instance
+                   | (oid: Integer) -> instance
+
+        def self.members: () -> [ :oid ]
+
+        def members: () -> [ :oid ]
+
+        attr_reader oid: Integer
+      end
+
+      class Tuple < ::Data
+        def self.new: (String type, String? data) -> instance
+                    | (type: String, data: String?) -> instance
+
+        def self.[]: (String type, String? data) -> instance
+                   | (type: String, data: String?) -> instance
+
+        def self.members: () -> [ :type, :data ]
+
+        def members: () -> [ :type, :data ]
+
+        attr_reader type: String
+
+        attr_reader data: String?
+
+        def text?: () -> Boolean
+
+        def binary?: () -> Boolean
+
+        def toast?: () -> Boolean
+      end
+
+      class Type < ::Data
+        def self.new: (Integer oid, String namespace, String name) -> instance
+                    | (oid: Integer, namespace: String, name: String) -> instance
+
+        def self.[]: (Integer oid, String namespace, String name) -> instance
+                   | (oid: Integer, namespace: String, name: String) -> instance
+
+        def self.members: () -> [ :oid, :namespace, :name ]
+
+        def members: () -> [ :oid, :namespace, :name ]
+
+        attr_reader oid: Integer
+
+        attr_reader namespace: String
+
+        attr_reader name: String
+      end
+
+      class Update < ::Data
+        def self.new: (Integer oid, Array[String] key, Array[String] old, Array[String] new) -> instance
+                    | (oid: Integer, key: Array[String], old: Array[String], new: Array[String]) -> instance
+
+        def self.[]: (Integer oid, Array[String] key, Array[String] old, Array[String] new) -> instance
+                   | (oid: Integer, key: Array[String], old: Array[String], new: Array[String]) -> instance
+
+        def self.members: () -> [ :oid, :key, :old, :new ]
+
+        def members: () -> [ :oid, :key, :old, :new ]
+
+        attr_reader oid: Integer
+
+        attr_reader key: Array[String]
+
+        attr_reader old: Array[String]
+
+        attr_reader new: Array[String]
+      end
+    end
+
+    @last_confirmed_lsn: Integer?
+
+    def start_replication_slot: (String slot, ?logical: bool, ?auto_keep_alive: bool, ?location: ::String, **untyped params) -> Enumerator::Lazy[PG::Replication::Protocol::PrimaryKeepalive | PG::Replication::Protocol::XLogData[String]]
+
+    def start_pgoutput_replication_slot: (String slot, Array[String] publication_names, **untyped kwargs) -> Enumerator::Lazy[PG::Replication::Protocol::PrimaryKeepalive | PG::Replication::Protocol::XLogData[PG::Replication::PGOutput]]
+
+    def standby_status_update: (write_lsn: Integer, ?flush_lsn: Integer, ?apply_lsn: Integer, ?timestamp: Time, ?reply: bool) -> void
+
+    def last_confirmed_lsn: () -> Integer?
+
+    def wal_receiver_status_interval: () -> Integer
+
+    def confirmed_slot_lsn: (String slot) -> Integer?
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pg-replication-protocol
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Rodrigo Navarro
 bindir: bin
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -41,6 +41,7 @@ files:
 - lib/pg/replication/protocol.rb
 - lib/pg/replication/version.rb
 - pg-replication-protocol.gemspec
+- sig/pg/replication.rbs
 licenses:
 - MIT
 metadata: