mqjob 0.4.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8e339bb78dcea031b930f7fab3203e5358c0103e4a2c2357b5c321e19fcd311
+  data.tar.gz: eecac402fb51319ff008756bc7ebdf0a005a45b2816b1bf44cb92403726793d4
+SHA512:
+  metadata.gz: 7ed6eb6e2c6642a4edfd0c73a2affc477a0b356150fb7c2d482561340534dd1febf22de73805e52d27948e204275ae188acda3310f3ab1d17ab0899ce253dd0a
+  data.tar.gz: ed2bd2477e35a535aeafc14271ec7b62ae5024e13ec781e56f09b46daf51cd307cb4fd425e0aca6126c6d6246a8e552eaf3fe5a7f589a31a628f8d2cd5e44dde

data/.gitignore

@@ -0,0 +1,51 @@
+# ---> Ruby
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://gems.ruby-china.com"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem 'pulsar_sdk', github: 'archfish/pulsar_sdk'
+
+gemspec

data/README.md

@@ -0,0 +1,118 @@
+# Mqjob
+
+A fast background processing framework for Ruby using MQ. MQ client was support as plugin. Current only implement Apache Pulsar. Name `Mqjob` was combine MQ and job.
+
+Inspired By [Sneakers](https://github.com/jondot/sneakers).
+
+## Examples
+
+- [initializer](examples/initializers.rb)
+- [rake task](examples/mqjob.rake)
+- [Single Job](examples/single_job.rb)
+- [Multiple Job](examples/multiple_job.rb)
+- Shell run `WORKERS=SingleJob,MultipleJob bundle exec rake mqjob:run`
+
+## API
+
+### Global Config
+
+  using in `Mqjob.configure`.
+
+  - client
+
+    An MQ client instance using in plugin. It should provide `producer` and `consumer` create api.
+
+  - plugin
+
+    Which implementing a specific MQ operations. Must implement basic interface:
+
+    ```ruby
+    def listen(topic, worker, opts = {}); end
+
+    def publish(topic, msg, opts = {}); end
+    ```
+
+    See [Pulsar](lib/plugin/pulsar.rb) for detail.
+
+  - daemonize
+
+    Config worker run to background.
+
+  - threads
+
+    How many Thread will create for job perform in process. It will init a thread pool.
+    IO-intensive tasks can be appropriately increased, and CPU-intensive tasks can be appropriately reduced.
+
+  - hooks
+
+    config `before_fork` and `after_fork`. NOT implement yet.
+    if you using ActiveRecord, set `wrap_perform` as follow avoid database connection broken.
+
+    ```ruby
+    Mqjob.configure do |config|
+      config.hooks = {
+        wrap_perform: lambda {|&b| ActiveRecord::Base.connection_pool.with_connection {b.call}}
+      }
+    end
+    ```
+
+  - subscription_mode
+
+    * exclusive
+
+      Same subscription name only one conumser can subscribe to a topic.
+
+    * failover
+
+      All subscribe to a topic only one can receive message, once the subscribe exit the remain pick one keep up.
+
+    * shared
+
+      All subscribe can receive message.
+
+  - logger
+
+    A log instance implement Ruby std logger interface.
+
+### Worker Config
+
+  - client
+
+    Using difference MQ client for this job. If connect to different types MQ you should config plugin at the same time.
+
+  - plugin
+
+    Using difference MQ client implement.
+
+  - prefetch
+
+    Config how many message per worker pull in one job cycle.
+
+  - subscription_mode
+
+    If set to `exclusive`, should provide subscription_name at the same time.
+
+  - subscription_name
+
+    Config subscription name, effects associated with subscription_mode.
+
+  - logger
+
+    Using difference logger for current worker.
+
+  - topic_type
+
+    * normal
+
+      Ordinary topic name. Default value.
+
+    * regex
+
+      The topic name is a regex, represent topics which match this regex. For example, `persistent://my-tenant/namespace2/topic_*` is all topics in namespace2 that match `/topic_*/`.
+
+## Note
+
+- Thread pool will not clean `Thread.current` when thread give back to pool. If you want to use thread storage [RequestStore](https://github.com/steveklabnik/request_store) recommended, it build in support.
+- database pool should not less than `threads` size.
+- Maybe you should use connection pool to manage database connection. Like PgBouncer for PostgreSQL, Druid for MySQL.
+- When topic_type is regex, message enqueue is not supported.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mqjob"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+Mqjob.configure {
+
+}
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mqjob.rb

@@ -0,0 +1,124 @@
+require 'logger'
+require "mqjob/version"
+require "mqjob/thread_pool"
+require 'serverengine'
+require 'mqjob/worker_group'
+require 'mqjob/worker'
+require 'plugin'
+require 'concurrent/configuration'
+
+module Mqjob
+  extend self
+
+  attr_reader :config
+
+  def configure(&block)
+    @config ||= Config.new
+
+    yield @config
+  end
+
+  def hooks
+    config&.hooks
+  end
+
+  def default_client
+    config&.client
+  end
+
+  # FIXME when job inherit from parent job it will not appear here!!
+  def registed_class
+    @registed_class ||= []
+  end
+
+  def regist_class(v)
+    @registed_class ||= []
+    @registed_class << v
+    @registed_class.uniq!
+  end
+
+  def logger
+    config.logger ||= ::Logger.new(STDOUT).tap do |logger|
+                        logger.formatter = Formatter.new
+                      end
+  end
+
+  class Config
+    attr_accessor :client,
+                  :plugin,
+                  :daemonize,
+                  :threads,
+                  :subscription_mode
+    attr_reader :logger, :hooks
+
+    def initialize(opts = {})
+      @hooks = Hooks.new(opts.delete(:hooks))
+      @plugin = :pulsar
+
+      assign_attributes(opts)
+
+      remove_empty_instance_variables!
+    end
+
+    def hooks=(v)
+      @hooks.update(v)
+    end
+
+    def logger=(v)
+      # fvcking Concurrent::Logging
+      unless v.respond_to?(:call)
+        v.class.class_eval <<-RUBY
+          def call(level, progname, message, &block)
+            add(level, message, progname, &block)
+          end
+        RUBY
+      end
+      @logger = v
+      Concurrent.global_logger = v
+    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 remove_empty_instance_variables!
+      instance_variables.each do |x|
+        remove_instance_variable(x) if instance_variable_get(x).nil?
+      end
+    end
+
+    class Hooks
+      attr_reader :before_fork, :after_fork, :wrap_perform
+
+      def initialize(opts)
+        update(opts)
+      end
+
+      def update(opts)
+        return if opts.nil? || opts.empty?
+
+        raise "hooks shuld be a Proc map!" unless opts.values.all?{|x| x.nil? || x.is_a?(Proc)}
+
+        @before_fork = opts[:before_fork]
+        @after_fork = opts[:after_fork]
+        @wrap_perform = opts[:wrap_perform]
+      end
+    end
+  end
+
+  class Formatter < ::Logger::Formatter
+    def call(severity, timestamp, progname, msg)
+      case msg
+      when ::StandardError
+        msg = [msg.message, msg&.backtrace].join(":\n")
+      end
+
+      super
+    end
+  end
+end

data/lib/mqjob/thread_pool.rb

@@ -0,0 +1,44 @@
+require 'concurrent/executors'
+
+module Mqjob
+  class ThreadPool < ::Concurrent::FixedThreadPool
+    def initialize(num_threads, opts = {})
+      super
+      @job_finish = ConditionVariable.new
+      @job_mutex = Mutex.new
+    end
+
+    # NOTE 使用非缓冲线程池，防止消息丢失
+    def post(*args, &task)
+      wait
+
+      super
+    end
+
+    def ns_execute
+      super
+
+      @job_finish.signal
+    end
+
+    def shutdown
+      super
+
+      @job_finish.broadcast
+    end
+
+    def kill
+      super
+
+      @job_finish.broadcast
+    end
+
+    def wait
+      @job_mutex.synchronize do
+        while running? && (scheduled_task_count - completed_task_count >= max_length)
+          @job_finish.wait(@job_mutex, 0.05)
+        end
+      end
+    end
+  end
+end

data/lib/mqjob/version.rb

@@ -0,0 +1,3 @@
+module Mqjob
+  VERSION = "0.4.6"
+end

data/lib/mqjob/worker.rb

@@ -0,0 +1,143 @@
+module Mqjob
+  module Worker
+    SUBSCRIPTION_MODES = [:exclusive, :failover, :shared].freeze
+
+    def initialize(opts)
+      @pool = opts[:pool]
+      @topic = self.class.topic
+      @topic_opts = self.class.topic_opts
+
+      @mq = Plugin.client(@topic_opts[:client])
+    end
+
+    def ack!; :ack end
+    def reject!; :reject; end
+    def requeue!; :requeue; end
+
+    def do_work(cmd, msg)
+      @pool.post do
+        begin
+          wrap_perform = ::Mqjob.hooks&.wrap_perform
+
+          ::Mqjob.logger.debug(__method__){'Begin process'}
+
+          if wrap_perform.nil?
+            process_work(cmd, msg)
+          else
+            wrap_perform.call do
+              process_work(cmd, msg)
+            end
+          end
+
+          ::Mqjob.logger.debug(__method__){'Finish process'}
+        rescue => exp
+          ::Mqjob.logger.error(__method__){"message process error: #{exp.message}! cmd: #{cmd}, msg: #{msg}"}
+          ::Mqjob.logger.error(__method__){exp}
+        end
+      end
+    end
+
+    def run
+      @mq.listen(@topic, self, @topic_opts)
+    end
+
+    def stop
+      @mq.close_listen
+    end
+
+    def perform(msg); end
+
+    private
+    def process_work(cmd, msg)
+      RequestStore.clear! if Object.const_defined?(:RequestStore)
+
+      result = nil
+      begin
+        result = if respond_to?(:perform_full_msg)
+          ::Mqjob.logger.info(__method__){"perform_full_msg: #{msg.inspect}"}
+          perform_full_msg(cmd, msg)
+        else
+          ::Mqjob.logger.info(__method__){"perform: #{msg.payload.inspect}"}
+          perform(msg.payload)
+        end
+      rescue => exp
+        ::Mqjob.logger.error(__method__){exp}
+        result = :error
+      end
+
+      case result
+      when :error, :reject
+        ::Mqjob.logger.info(__method__) {"Redeliver messages! Current message id is: #{msg.message_id.inspect}"}
+        msg.nack
+      when :requeue
+        ::Mqjob.logger.info(__method__) {"Requeue! message id is: #{msg.message_id.inspect}"}
+        msg.ack
+        self.class.enqueue(msg.payload, in: 10)
+      else
+        ::Mqjob.logger.info(__method__) {"Acknowledge message!"}
+        msg.ack
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      ::Mqjob.regist_class(base) if base.is_a? Class
+    end
+
+    module ClassMethods
+      attr_reader :topic_opts
+      attr_reader :topic
+
+      # client: MQ,
+      # plugin: :pulsar,
+      # prefetch: 1,
+      # subscription_mode: SUBSCRIPTION_MODES, # 不同类型需要不同配置参数，互斥模式下需要指定订阅名
+      # subscription_name
+      # logger: MyLogger
+      # topic_type [:normal, :regex] default normal
+      def from_topic(name, opts={})
+        @topic = name.respond_to?(:call) ? name.call : name
+        @topic_opts = opts
+
+        topic_type = @topic_opts[:topic_type]&.to_sym
+        @topic_opts[:topic_type] = topic_type || :normal
+
+        @topic_opts[:subscription_name] ||= (self.name.split('::') << 'Consumer').join
+      end
+
+      # opts
+      #   in publish message in X seconds
+      #   at publish message at specific time
+      #   init_subscription Boolean 是否先初始化一个订阅
+      #   perform_now Boolean 立即执行，通常用于测试环境减少流程
+      def enqueue(msg, opts={})
+        if topic_opts[:topic_type] != :normal
+          ::Mqjob.logger.error(__method__){
+            "message enqueue only support topic_type set to normal, but got 「#{topic_opts[:topic_type]}」! After action skipped!"
+          }
+          return false
+        end
+
+        if !opts[:perform_now]
+          @mq ||= Plugin.client(topic_opts[:client])
+          @mq.publish(topic, msg, topic_opts.merge(opts))
+          return true
+        end
+
+        begin
+          worker = self.new({})
+          if worker.respond_to?(:perform)
+            msg = JSON.parse(JSON.dump(msg))
+            ::Mqjob.logger.info('perform message now'){msg.inspect}
+            worker.send(:process_work, nil, OpenStruct.new(payload: msg))
+          else
+            ::Mqjob.logger.error('perform_now required 「perform」 method, 「perform_full_msg」not supported!')
+          end
+        rescue => exp
+          ::Mqjob.logger.error("#{self.name} perform_now") {exp}
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mqjob/worker_group.rb

@@ -0,0 +1,71 @@
+module Mqjob
+  module WorkerGroup
+    def initialize
+      @stoped = false
+      # 统一线程池，防止数据库连接池不够用，推荐设置为10
+      @pool = ::Mqjob::ThreadPool.new(threads)
+    end
+
+    def before_fork
+      ::Mqjob.hooks.before_fork&.call
+    end
+
+    def run
+      return if @stoped
+
+      ::Mqjob.hooks.after_fork&.call
+
+      workers.each do |worker|
+        worker.run
+      end
+    end
+
+    def stop
+      workers.each{|wc| wc.stop}
+
+      @stoped = true
+    end
+
+    def reload
+      puts "call #{__method__}"
+    end
+
+    def after_start
+      puts "call #{__method__}"
+    end
+
+    def workers
+      @workers ||= worker_classes.map do |wc|
+        wc.new(pool: @pool)
+      end
+    end
+
+    # 设置线程数并返回新类型
+    # opts
+    #   threads 设置线程池大小
+    def self.configure(opts)
+      thread_size = opts[:threads]
+      raise "threads was required!" if thread_size.to_i.zero?
+      workers = Array(opts[:clazz])
+      raise "clazz was required!" if workers.empty?
+
+      md = Module.new
+      md_name = "WorkerGroup#{md.object_id}".tr('-', '_')
+
+      md.include(self)
+      md.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def threads
+          #{thread_size}
+        end
+
+        def worker_classes
+          #{workers}
+        end
+
+        private :threads, :workers
+      RUBY
+
+      ::Mqjob.const_set(md_name, md)
+    end
+  end
+end

data/lib/plugin.rb

@@ -0,0 +1,24 @@
+require 'plugin/base'
+
+module Plugin
+  extend self
+
+  def client(c, plugin: nil)
+    plugin = init_plugin(plugin)
+    c ||= Mqjob.default_client
+
+    Plugin.const_get(plugin).new(c)
+  end
+
+  def init_plugin(name)
+    name ||= Mqjob.config.plugin
+
+    Mqjob.logger.debug("#{self.name}::#{__method__}"){"select plugin: #{name}"}
+
+    require "plugin/#{name}"
+
+    name.to_s.capitalize
+  end
+
+  private :init_plugin
+end

data/lib/plugin/base.rb

@@ -0,0 +1,15 @@
+module Plugin
+  class Base
+    def initialize(client)
+      @client = client
+      @subscription_mode = ::Mqjob.config.subscription_mode
+    end
+
+    def listen(topic, worker, opts = {}); end
+
+    def publish(topic, msg, opts = {}); end
+
+    def close_listen; end
+    def close_publish; end
+  end
+end

data/lib/plugin/pulsar.rb

@@ -0,0 +1,92 @@
+require 'pulsar_sdk'
+
+module Plugin
+  class Pulsar < Base
+    def listen(topic, worker, opts = {})
+      create_consumer(topic, opts).listen do |cmd, msg|
+        ::Mqjob.logger.debug("#{self.class.name}::#{__method__}"){"receive msg: #{msg.payload}"}
+        worker.do_work(cmd, msg)
+      end
+    end
+
+    # opts
+    #   in publish message in X seconds
+    #   at publish message at specific time
+    #   init_subscription Boolean
+    def publish(topic, msg, opts = {})
+      create_consumer(topic, opts) if opts[:init_subscription]
+
+      base_cmd = ::Pulsar::Proto::BaseCommand.new(
+        type: ::Pulsar::Proto::BaseCommand::Type::SEND,
+        send: ::Pulsar::Proto::CommandSend.new(
+          num_messages: 1
+        )
+      )
+
+      get_timestamp = lambda {|v| (v.to_f * 1000).floor}
+
+      deliver_at = case
+                  when opts[:in]
+                    Time.now.localtime + opts[:in].to_f
+                  when opts[:at]
+                    opts[:at]
+                  else
+                    Time.now.localtime
+                  end
+
+      metadata = ::Pulsar::Proto::MessageMetadata.new(
+        deliver_at_time: get_timestamp.call(deliver_at)
+      )
+      p_msg = ::PulsarSdk::Producer::Message.new(msg, metadata)
+
+      create_producer(topic, opts).execute_async(base_cmd, p_msg)
+    end
+
+    def close_listen
+      @consumer&.close
+    end
+
+    def close_publish
+      @producer&.close
+    end
+
+    private
+    def create_consumer(topic, opts)
+      @consumer ||= begin
+        topic_type = :topic
+        if opts[:topic_type].to_sym == :regex
+          topic_type = :topics_pattern
+        elsif topic.is_a?(Array)
+          topic_type = :topics
+        end
+
+        consumer_opts = ::PulsarSdk::Options::Consumer.new(
+          topic_type => topic,
+          subscription_type: (opts[:subscription_mode] || @subscription_mode).to_s.capitalize.to_sym,
+          subscription_name: opts[:subscription_name],
+          prefetch: opts[:prefetch] || 1,
+          listen_wait: 0.1
+        )
+
+        ::Mqjob.logger.debug(__method__){consumer_opts.inspect}
+
+        @client.subscribe(consumer_opts)
+      end
+    end
+
+    def create_producer(topic, opts)
+      @producer ||= begin
+        producer_opts = ::PulsarSdk::Options::Producer.new(
+          topic: topic
+        )
+
+        @client.create_producer(producer_opts)
+      end
+    end
+
+  end
+end
+
+# NOTE
+#   ServerEngine会自动循环调用，所以这里使用无阻塞listen即可
+#   如果这里listen阻塞会导致同组任务无法正常执行

data/mqjob.gemspec

@@ -0,0 +1,30 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mqjob/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mqjob"
+  spec.version       = Mqjob::VERSION
+  spec.authors       = 'archfish'
+  spec.email         = ["weihailang@gmail.com"]
+  spec.license       = 'Apache License 2.0'
+
+  spec.summary       = %q{A queue job base on Apache Pulsar}
+  spec.description   = %q{A queue job base on Apache Pulsar}
+  spec.homepage      = "https://github.com/archfish/mqjob"
+
+  # 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 'serverengine', '~> 2.2'
+  spec.add_dependency 'concurrent-ruby', '~> 1.1'
+
+  spec.add_development_dependency "bundler", "> 1.17"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: mqjob
+version: !ruby/object:Gem::Version
+  version: 0.4.6
+platform: ruby
+authors:
+- archfish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: serverengine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+description: A queue job base on Apache Pulsar
+email:
+- weihailang@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mqjob.rb
+- lib/mqjob/thread_pool.rb
+- lib/mqjob/version.rb
+- lib/mqjob/worker.rb
+- lib/mqjob/worker_group.rb
+- lib/plugin.rb
+- lib/plugin/base.rb
+- lib/plugin/pulsar.rb
+- mqjob.gemspec
+homepage: https://github.com/archfish/mqjob
+licenses:
+- Apache License 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: A queue job base on Apache Pulsar
+test_files: []