grpc-dc 0.37.1

data/lib/grpcdc/eventbus_git.rb

@@ -0,0 +1,132 @@
+# @generated by grpc-dc codegen. DO NOT EDIT.
+# SPDX-License-Identifier: Apache-2.0
+# Git log serde for the event bus: exports an event log to a
+# git branch (one commit per event) and imports it back. The
+# live broker never touches git; this is the durable serde
+# layer beside it. Stdlib Open3 drives the git plumbing.
+#
+# Deterministic: the same events always produce the same
+# commits, so re-exporting a log the branch already has is a
+# no-op (each event's sequence number is the dedup key). The
+# commit blob (event.pb) is authoritative; the message subject and
+# trailers are a human index for `git log`.
+
+require "open3"
+
+require_relative "eventbus"
+require_relative "events_pb"
+
+module Grpcdc
+  module EventbusGit
+    AUTHOR_NAME = "grpc-dc eventbus"
+    AUTHOR_EMAIL = "eventbus@grpc-dc.local"
+    BLOB_PATH = "event.pb"
+    COMMIT_SUBJECT = "grpc-dc event"
+    TRAILER_SEQ = "Seq"
+    TRAILER_PUBLISHER = "Publisher"
+    TRAILER_TAG = "Tag"
+    ZERO_SHA = "0" * 40
+
+    EVENT_LOG_BRANCH = "grpc-dc-events"
+
+    def self.git(repo, args, input_bytes = nil, env_extra = nil)
+      out, _err, status = Open3.capture3(env_extra || {}, "git", "-C", repo, *args, stdin_data: input_bytes || "".b)
+      raise "git #{args.first} failed in #{repo}" unless status.success?
+
+      out
+    end
+
+    def self.git_text(repo, args, input_bytes = nil, env_extra = nil)
+      git(repo, args, input_bytes, env_extra).strip
+    end
+
+    # Create the log repo if needed (a plain `git init`).
+    def self.init_event_log_repo(repo)
+      git_text(repo, ["rev-parse", "--git-dir"])
+    rescue StandardError
+      out, _err, status = Open3.capture3("git", "init", "-q", repo)
+      raise "git init failed for #{repo}" unless status.success?
+
+      out
+    end
+
+    def self.branch_head(repo, branch)
+      git_text(repo, ["rev-parse", "--verify", "refs/heads/#{branch}"])
+    rescue StandardError
+      nil
+    end
+
+    # "grpc-dc event 42" plus Seq/Publisher/Tag trailers, so
+    # `git log` alone can filter the log without decoding blobs.
+    def self.commit_message(event)
+      lines = ["#{COMMIT_SUBJECT} #{event.seq}", "", "#{TRAILER_SEQ}: #{event.seq}"]
+      lines << "#{TRAILER_PUBLISHER}: #{event.publisher_id}" unless event.publisher_id.empty?
+      (event.tags || []).each { |tv| lines << "#{TRAILER_TAG}: #{Eventbus.tag_value_key(tv)}" }
+      lines.join("\n") + "\n"
+    end
+
+    def self.commit_env(event)
+      seconds = [0, event.timestamp_unix_ms / 1000].max
+      date = "#{seconds} +0000"
+      {
+        "GIT_AUTHOR_NAME" => AUTHOR_NAME,
+        "GIT_AUTHOR_EMAIL" => AUTHOR_EMAIL,
+        "GIT_COMMITTER_NAME" => AUTHOR_NAME,
+        "GIT_COMMITTER_EMAIL" => AUTHOR_EMAIL,
+        "GIT_AUTHOR_DATE" => date,
+        "GIT_COMMITTER_DATE" => date
+      }
+    end
+
+    # Import a branch: events in chain order (oldest first),
+    # optionally windowed by sequence number and narrowed by a
+    # tag filter (same containment semantics as Subscribe). A
+    # missing branch imports as an empty log.
+    def self.import_events(repo, branch = EVENT_LOG_BRANCH, from_seq: 0, to_seq: nil, filter_tags: nil)
+      return [] if branch_head(repo, branch).nil?
+
+      events = []
+      git_text(repo, ["rev-list", "--reverse", branch]).split("\n").each do |sha|
+        next if sha.empty?
+
+        data = git(repo, ["cat-file", "-p", "#{sha}:#{BLOB_PATH}"])
+        event = EventsPb::Event.new
+        event.unmarshal_dc(data)
+        next if event.seq <= from_seq
+        next if !to_seq.nil? && event.seq > to_seq
+        next if filter_tags && !Eventbus.tags_match(event.tags, filter_tags)
+
+        events << event
+      end
+      events
+    end
+
+    # Export events onto the branch: one commit per event, in
+    # sequence order, skipping sequence numbers the branch
+    # already has. Returns the new head sha (or the existing one
+    # when nothing was appended). The ref update is a
+    # compare-and-swap: a concurrent exporter fails loudly
+    # instead of forking the log; retrying is safe.
+    def self.export_events(repo, events, branch = EVENT_LOG_BRANCH)
+      init_event_log_repo(repo)
+      existing = {}
+      import_events(repo, branch).each { |e| existing[e.seq] = true }
+      head = branch_head(repo, branch)
+      before = head
+      events.sort_by(&:seq).each do |event|
+        next if existing.key?(event.seq)
+
+        blob = git_text(repo, ["hash-object", "-w", "--stdin"], event.marshal_dc)
+        tree = git_text(repo, ["mktree"], "100644 blob #{blob}\t#{BLOB_PATH}\n".encode(Encoding::UTF_8))
+        args = ["commit-tree", tree, "-m", commit_message(event)]
+        args += ["-p", head] unless head.nil?
+        head = git_text(repo, args, nil, commit_env(event))
+        existing[event.seq] = true
+      end
+      if !head.nil? && head != before
+        git_text(repo, ["update-ref", "refs/heads/#{branch}", head, before || ZERO_SHA])
+      end
+      head
+    end
+  end
+end

data/lib/grpcdc/events_grpc_dc.rb

@@ -0,0 +1,232 @@
+# Generated code: use without restriction (see GENERATED-CODE-LICENSE.md).
+# @generated by protoc-gen-grpc-dc-ruby. DO NOT EDIT.
+# source: events.proto
+
+require_relative "events_pb"
+require "grpcdc"
+
+module EventsGrpcDc
+  # Client receiving stream: recv raises EOFError at end.
+  class RecvStream
+    include Enumerable
+
+    def initialize(stream, resp_cls)
+      @stream = stream
+      @resp_cls = resp_cls
+    end
+
+    def recv
+      @stream.recv(@resp_cls.new)
+    end
+
+    # Response initial metadata (after the first recv).
+    def headers
+      @stream.headers&.metadata
+    end
+
+    # Response trailing metadata (after the call ends).
+    def trailers
+      @stream.trailers
+    end
+
+    # Abandon the call early: RST so the server stops producing.
+    def cancel
+      @stream.cancel
+    end
+
+    def close
+      @stream.cancel
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      begin
+        loop do
+          begin
+            yield recv
+          rescue EOFError
+            return
+          end
+        end
+      ensure
+        # Breaking out of the block abandons the call: RST so
+        # the server stops producing (no-op once terminated).
+        close
+      end
+    end
+  end
+
+  # Server-streaming sink passed to service implementations.
+  class SendStream
+    attr_reader :context
+
+    def initialize(ctx, sink)
+      @context = ctx
+      @sink = sink
+    end
+
+    def send(resp)
+      @sink.send(resp.marshal_dc)
+    end
+  end
+
+  # Client-streaming stream passed to service implementations.
+  class ClientStreamImpl
+    attr_reader :context, :resp
+
+    def initialize(ctx, reqs, req_cls)
+      @context = ctx
+      @reqs = reqs
+      @req_cls = req_cls
+      @resp = nil
+    end
+
+    def recv
+      @reqs.recv_into(@req_cls.new)
+    end
+
+    def send_and_close(resp)
+      @resp = resp
+    end
+  end
+
+  # Bidi stream passed to service implementations.
+  class BidiStream
+    attr_reader :context
+
+    def initialize(ctx, reqs, sink, req_cls)
+      @context = ctx
+      @reqs = reqs
+      @sink = sink
+      @req_cls = req_cls
+    end
+
+    def send(resp)
+      @sink.send(resp.marshal_dc)
+    end
+
+    def recv
+      @reqs.recv_into(@req_cls.new)
+    end
+  end
+
+  # Fiber-based client receiving stream: a producer Fiber
+  # yields each response; next_msg resumes it and raises
+  # StopIteration when the call completes. cancel aborts
+  # the underlying stream (RST).
+  class FiberRecvStream
+    include Enumerable
+
+    DONE = Object.new
+
+    def initialize(stream, resp_cls)
+      @stream = stream
+      @resp_cls = resp_cls
+      @fiber = Fiber.new do
+        begin
+          loop { Fiber.yield(@stream.recv(@resp_cls.new)) }
+        rescue EOFError
+          DONE
+        end
+      end
+    end
+
+    def next_msg
+      value = @fiber.resume
+      raise StopIteration if value.equal?(DONE)
+
+      value
+    end
+
+    # Response initial metadata (after the first recv).
+    def headers
+      @stream.headers&.metadata
+    end
+
+    # Response trailing metadata (after the call ends).
+    def trailers
+      @stream.trailers
+    end
+
+    def cancel
+      @stream.cancel
+    end
+
+    def close
+      @stream.cancel
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      begin
+        loop do
+          begin
+            yield next_msg
+          rescue StopIteration
+            return
+          end
+        end
+      ensure
+        # Breaking out of the block abandons the call: RST so
+        # the server stops producing (no-op once terminated).
+        close
+      end
+    end
+  end
+
+  class EventBusClient
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def Publish(req, metadata = nil, timeout: nil)
+      @channel.unary("/grpcdc.events.v1.EventBus/Publish", req, EventsPb::PublishReply.new, metadata, timeout: timeout)
+    end
+
+    def Subscribe(req, metadata = nil, timeout: nil)
+      stream = @channel.server_stream("/grpcdc.events.v1.EventBus/Subscribe", req, metadata, timeout: timeout)
+      RecvStream.new(stream, EventsPb::Event)
+    end
+
+  end
+
+  # Fiber client: wraps a Grpcdc::FiberChannel (a sync Channel is wrapped).
+  class EventBusClientFiber
+    def initialize(channel)
+      @channel = channel.is_a?(Grpcdc::FiberChannel) ? channel : Grpcdc::FiberChannel.new(channel)
+    end
+
+    def Publish(req, metadata = nil, timeout: nil)
+      @channel.unary("/grpcdc.events.v1.EventBus/Publish", req, EventsPb::PublishReply.new, metadata, timeout: timeout)
+    end
+
+    def Subscribe(req, metadata = nil, timeout: nil)
+      stream = @channel.server_stream("/grpcdc.events.v1.EventBus/Subscribe", req, metadata, timeout: timeout)
+      FiberRecvStream.new(stream, EventsPb::Event)
+    end
+
+  end
+
+  def self.register_event_bus_server(server, impl)
+    publish_handler = lambda do |ctx, reqs, sink|
+      req = reqs.recv_into(EventsPb::PublishRequest.new)
+      resp = impl.Publish(ctx, req)
+      sink.send(resp.marshal_dc)
+    end
+
+    subscribe_handler = lambda do |ctx, reqs, sink|
+      req = reqs.recv_into(EventsPb::SubscribeRequest.new)
+      impl.Subscribe(req, SendStream.new(ctx, sink))
+    end
+
+    server.register_service(Grpcdc::ServiceDesc.new(
+      "grpcdc.events.v1.EventBus",
+      [
+        Grpcdc::Method.new("Publish", "/grpcdc.events.v1.EventBus/Publish", Grpcdc::KIND_UNARY, publish_handler),
+        Grpcdc::Method.new("Subscribe", "/grpcdc.events.v1.EventBus/Subscribe", Grpcdc::KIND_SERVER_STREAMING, subscribe_handler),
+      ]
+    ))
+  end
+end