pulsar_sdk 0.8.8

data/lib/pulsar_sdk/tweaks.rb

@@ -0,0 +1,10 @@
+require 'pulsar_sdk/tweaks/assign_attributes'
+require 'pulsar_sdk/tweaks/clean_inspect'
+require 'pulsar_sdk/tweaks/base_command'
+require 'pulsar_sdk/tweaks/time_at_microsecond'
+require 'pulsar_sdk/tweaks/timeout_queue'
+require 'pulsar_sdk/tweaks/wait_map'
+require 'pulsar_sdk/tweaks/binary_heap'
+
+# 扩展type的判断方法，方便书写，统一以 typeof_ 开头
+Pulsar::Proto::BaseCommand.prepend PulsarSdk::Tweaks::BaseCommand

data/lib/pulsar_sdk/tweaks/assign_attributes.rb

@@ -0,0 +1,30 @@
+module PulsarSdk
+  module Tweaks
+    module AssignAttributes
+      def initialize(opts = {})
+        set_default
+
+        assign_attributes(opts)
+
+        remove_empty_instance_variables!
+      end
+
+      def assign_attributes(opts)
+        opts.each do |k, v|
+          method = "#{k}="
+          next unless self.respond_to?(method)
+          self.public_send method, v
+        end
+      end
+
+      private
+      def set_default; end
+
+      def remove_empty_instance_variables!
+        instance_variables.each do |x|
+          remove_instance_variable(x) if instance_variable_get(x).nil?
+        end
+      end
+    end
+  end
+end

data/lib/pulsar_sdk/tweaks/base_command.rb

@@ -0,0 +1,66 @@
+module PulsarSdk
+  module Tweaks
+    module BaseCommand
+      attr_accessor :seq_generator
+
+      # add some helper
+      #   def set_request_id
+      #   def set_consumer_id
+      #   def set_producer_id
+      #   def set_sequence_id
+      #   def get_request_id
+      #   def get_consumer_id
+      #   def get_producer_id
+      #   def get_sequence_id
+      # NOTE before use setter must set `seq_generator`
+      [:request_id, :consumer_id, :producer_id, :sequence_id].each do |x|
+        define_method "set_#{x}" do
+          if self.seq_generator.nil?
+            PulsarSdk.logger.warn(__method__){"seq_generator was not set!! action has no effect"}
+            return
+          end
+
+          method_ = "#{x}="
+          current_id = nil
+          attribute_names.each do |name|
+            next unless self[name].respond_to?(method_)
+
+            # NOTE keep same id name with same value, like sequence_id
+            current_id ||= self.seq_generator.public_send("new_#{x}")
+
+            self[name].public_send(method_, current_id)
+          end
+
+          current_id
+        end
+
+        define_method "get_#{x}" do
+          attribute_names.each do |name|
+            next unless self[name].respond_to?(x)
+            return self[name][x.to_s]
+          end
+          nil
+        end
+      end
+
+      Pulsar::Proto::BaseCommand::Type.constants.each do |x|
+        method = "typeof_#{x.to_s.downcase}?"
+        define_method method do
+          self.type == x
+        end
+      end
+
+      def handle_ids
+        set_request_id
+        set_consumer_id
+        set_producer_id
+        set_sequence_id
+      end
+
+      private
+      def attribute_names
+        self.class.descriptor.map(&:name)
+      end
+    end
+  end
+end

data/lib/pulsar_sdk/tweaks/binary_heap.rb

@@ -0,0 +1,133 @@
+module PulsarSdk
+  module Tweaks
+    class BinaryHeap
+      attr_reader :data
+
+      # default is max heap, custom compare lambda to build your sort
+      def initialize(ary=nil, &block)
+        @cmp = block || lambda{|parent, child| parent <=> child }
+        @mutex = Mutex.new
+
+        raise "type of ary must be Array or its subclass" unless ary.nil? || ary.is_a?(Array)
+        @data = build_from(ary)
+      end
+
+      # insert an element list into heap, it will automatic adjust
+      def insert(*elements)
+        @mutex.synchronize do
+          elements.each do |x|
+            data.push(x)
+            adjust(:bottom_up)
+          end
+        end
+      end
+
+      # take the heap element and adjust heap
+      def shift
+        @mutex.synchronize do
+          return if data.empty?
+          e = data.first
+          data[0] = data.last
+          data.pop
+          adjust(:top_down)
+          e
+        end
+      end
+
+      # return the the top element of the heap
+      def top
+        data.first
+      end
+
+      private
+      def build_from(ary)
+        return [] if ary.nil? || ary.empty?
+
+        heap = BinaryHeap.new(&(@cmp))
+        heap.insert(*ary)
+        heap.data
+      end
+
+      def swap(i, j)
+        data[i], data[j] = data[j], data[i]
+      end
+
+      def compare(i, j)
+        @cmp.call(data[i], data[j]) >= 0
+      end
+
+      def p_idx(child_idx)
+        return nil if child_idx == 0
+        child_idx%2 == 0 ? (child_idx-2)/2 : child_idx/2
+      end
+
+      def l_idx(parent_idx)
+        (parent_idx << 1) + 1
+      end
+
+      def r_idx(parent_idx)
+        (parent_idx << 1) + 2
+      end
+
+      def lchid(parent_idx)
+        data[l_idx(parent_idx)]
+      end
+
+      def rchild(parent_idx)
+        data[r_idx(parent_idx)]
+      end
+
+      def good?(idx)
+        if !lchid(idx).nil?
+          return false unless compare(idx, l_idx(idx))
+        end
+
+        if !rchild(idx).nil?
+          return false unless compare(idx, r_idx(idx))
+        end
+
+        true
+      end
+
+      # make the heap in good shape
+      def adjust(direction = :top_down)
+        return if data.size < 2
+
+        case direction
+        when :top_down
+          parent_idx = 0
+          until good?(parent_idx)
+            child_idx = find_child_idx(parent_idx)
+            swap(parent_idx, child_idx)
+            parent_idx = child_idx
+          end
+        when :bottom_up
+          child_idx = data.size - 1
+          parent_idx = p_idx(child_idx)
+          until child_idx == 0 || compare(parent_idx, child_idx)
+            swap(parent_idx, child_idx)
+            child_idx = parent_idx
+            parent_idx = p_idx(child_idx)
+          end
+        else
+          raise "invalid direction type"
+        end
+      end
+
+      def find_child_idx(parent_idx)
+        l = lchid(parent_idx)
+        r = rchild(parent_idx)
+
+        return if l.nil? && r.nil?
+
+        l_idx_ = l_idx(parent_idx)
+        r_idx_ = r_idx(parent_idx)
+
+        return r_idx_ if l.nil?
+        return l_idx_ if r.nil?
+
+        compare(l_idx_, r_idx_) ? l_idx_ : r_idx_
+      end
+    end
+  end
+end

data/lib/pulsar_sdk/tweaks/clean_inspect.rb

@@ -0,0 +1,15 @@
+module PulsarSdk
+  module Tweaks
+    module CleanInspect
+      def inspect
+        s = instance_variables.map do |x|
+          v = instance_variable_get(x)
+          next if v.is_a?(Proc)
+          "#{x}: #{v}"
+        end.join(', ')
+
+        "<#{self.class.name} #{s}>"
+      end
+    end
+  end
+end

data/lib/pulsar_sdk/tweaks/time_at_microsecond.rb

@@ -0,0 +1,27 @@
+module PulsarSdk
+  module Tweaks
+    module TimeAtMicrosecond
+      def self.prepended(base)
+        class << base
+          prepend ClassMethods
+        end
+      end
+
+      def timestamp
+        (self.to_f * 1000).floor
+      end
+
+      module ClassMethods
+        def at_timestamp(v)
+          second, micro = v.divmod(1000)
+          self.at(second, micro * 1000)
+        end
+      end
+    end
+  end
+end
+
+# 扩展默认时间方法，增加毫秒时间戳相关处理
+class TimeX < Time
+  prepend PulsarSdk::Tweaks::TimeAtMicrosecond
+end

data/lib/pulsar_sdk/tweaks/timeout_queue.rb

@@ -0,0 +1,52 @@
+module PulsarSdk
+  module Tweaks
+    class TimeoutQueue
+      def initialize
+        @mutex = Mutex.new
+        @queue = []
+        @received = ConditionVariable.new
+        @closed = false
+      end
+
+      def add(*args)
+        @mutex.synchronize do
+          @queue << args
+          @received.signal
+        end
+      end
+
+      def clear
+        @mutex.synchronize do
+          @queue.clear
+        end
+      end
+
+      def size
+        @queue.size
+      end
+
+      # timeout 数字，单位秒
+      def pop(timeout = nil)
+        @mutex.synchronize do
+          if timeout.nil?
+            while !@closed && @queue.empty?
+              @received.wait(@mutex)
+            end
+          elsif @queue.empty? && timeout != 0
+            timeout_at = TimeX.now.to_f + timeout
+            while !@closed && @queue.empty? && (res = timeout_at - TimeX.now.to_f) > 0
+              @received.wait(@mutex, res)
+            end
+          end
+
+          @queue.pop
+        end
+      end
+
+      def close
+        @closed = true
+        @received.broadcast
+      end
+    end
+  end
+end

data/lib/pulsar_sdk/tweaks/wait_map.rb

@@ -0,0 +1,81 @@
+module PulsarSdk
+  module Tweaks
+    class WaitMap
+      def initialize
+        @mutex = Mutex.new
+        @map = {}
+
+        @wait = {}
+        @closed = false
+      end
+
+      def add(id, value)
+        @mutex.synchronize do
+          @map[id] = value
+          _, signal = @wait[id]
+          signal.signal unless signal.nil?
+        end
+        value
+      end
+
+      def clear
+        @mutex.synchronize do
+          @map.each {|k, v| yield k, v} if block_given?
+
+          @map = {}
+        end
+        true
+      end
+
+      def each(&block)
+        @mutex.synchronize do
+          @map.each {|k, v| yield k, v}
+        end
+      end
+
+      # 不会删除元素
+      def find(id)
+        @mutex.synchronize do
+          @map[id]
+        end
+      end
+
+      def delete(id, timeout = nil)
+        mutex, signal = []
+
+        @mutex.synchronize do
+          return @map.delete(id) if @map.has_key?(id)
+
+          @wait[id] ||= [Mutex.new, ConditionVariable.new]
+          mutex, signal = @wait[id]
+        end
+
+        mutex.synchronize do
+          if timeout.nil?
+            while !@closed && !@map.has_key?(id)
+              signal.wait(mutex)
+            end
+          elsif @map.empty? && timeout != 0
+            timeout_at = TimeX.now.to_f + timeout
+            while !@closed && !@map.has_key?(id) && (res = timeout_at - TimeX.now.to_f) > 0
+              signal.wait(mutex, res)
+            end
+          end
+        end
+
+        @mutex.synchronize do
+          @wait.delete id
+          @map.delete id
+        end
+      end
+
+      def close
+        @closed = true
+        @wait.each do |_, v|
+          _, signal = v
+          signal.broadcast
+        end
+      end
+    end
+  end
+end

data/lib/pulsar_sdk/version.rb

@@ -0,0 +1,3 @@
+module PulsarSdk
+  VERSION = "0.8.8"
+end

data/pulsar_sdk.gemspec

@@ -0,0 +1,31 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pulsar_sdk/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pulsar_sdk"
+  spec.version       = PulsarSdk::VERSION
+  spec.authors       = 'archfish'
+  spec.email         = ["weihailang@gmail.com"]
+  spec.license       = 'Apache License 2.0'
+
+  spec.summary       = %q{A pure ruby client for Apache Pulsar}
+  spec.description   = %q{A pure ruby client for Apache Pulsar}
+  spec.homepage      = "https://github.com/archfish/pulsar_sdk"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|examples)/}) }
+  end
+
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'google-protobuf', '~> 3.11'
+  spec.add_dependency 'digest-crc', '~> 0.4'
+
+  spec.add_development_dependency "bundler", "> 1.17"
+  spec.add_development_dependency "rake", "> 10"
+end