jobi 0.1.1

data/examples/normal_job.rb

@@ -0,0 +1,39 @@
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'jobi'
+
+class NormalJob < Jobi::Job
+  options queue_name: :calculators,
+          ack: true,
+          consumers: 10
+
+  after_run :publish_result
+
+  def initialize(a:, b:)
+    @first = a
+    @second = b
+  end
+
+  def run
+    @sum = @first + @second
+  end
+
+  def publish_result
+    puts "publishing result: #{@sum}"
+  end
+end
+
+Jobi.configure do |config|
+  config.rabbitmq
+  config.act_as_publisher = true
+  config.act_as_consumer = true
+  config.jobs = ['NormalJob']
+end
+
+started_at = Time.now.to_f
+
+(1..ENV['TIMES'].to_i).each do
+  NormalJob.run(a: 1, b: 2)
+end
+
+puts "took: #{Time.now.to_f - started_at}"

data/jobi.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/jobi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jobi"
+  spec.version       = Jobi::VERSION
+  spec.authors       = ["Rudy Zidan"]
+  spec.email         = ["rz.zidan@gmail.com"]
+
+  spec.summary       = "A simple message brokers framework for Ruby."
+  spec.description   = "Jobi provides a full interaction between your app/micro-service and message brokers."
+  spec.homepage      = "https://www.github.com/Rudy-Zidan/jobi"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://www.github.com/Rudy-Zidan/jobi"
+  spec.metadata["changelog_uri"] = "https://www.github.com/Rudy-Zidan/jobi/blob/master/CHANGELOG.md"
+
+  # 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)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'bunny', ">= 2.14.1"
+  spec.add_dependency 'logger'
+  spec.add_dependency 'rspec', "~> 3.0"
+end

data/lib/jobi.rb

@@ -0,0 +1,64 @@
+require 'jobi/version'
+require 'logger'
+require 'jobi/utils'
+require 'jobi/job'
+require 'jobi/configuration'
+require 'jobi/config/rabbitmq'
+require 'jobi/clients/rabbitmq'
+require 'jobi/consumers/rabbitmq'
+
+module Jobi
+  class Error < StandardError; end
+
+  class << self
+    include Utils
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      configuration.setup_logger
+      start
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def session
+      @session ||= client_class.new(configuration.send(client_config_method))
+    end
+
+    def client_class_name
+      configuration.client.capitalize
+    end
+
+    def consumer?
+      configuration.act_as_consumer
+    end
+
+    def publisher?
+      configuration.act_as_publisher
+    end
+
+    private
+
+    def client_config_method
+      "#{client_class_name.downcase}_config"
+    end
+
+    def client_class
+      constantize("Jobi::Clients::#{client_class_name}")
+    end
+
+    def start
+      return unless consumer?
+
+      configuration.jobs.each do |job_klass|
+        constantize(job_klass).consume_messages
+      end
+    end
+  end
+end

data/lib/jobi/clients/rabbitmq.rb

@@ -0,0 +1,29 @@
+require 'bunny'
+
+module Jobi
+  module Clients
+    class Rabbitmq
+      def initialize(config = Jobi::Config::Rabbitmq.new)
+        @connection = Bunny.new(config.to_h)
+        @connection.start
+      end
+
+      def channel
+        @channel ||= @connection.create_channel
+      end
+
+      def default_exchange
+        @default_exchange ||= channel.default_exchange
+      end
+
+      def queue(name:, options: {})
+        default_exchange
+        channel.queue(name)
+      end
+
+      def publish(message:, queue:, options: {})
+        queue.publish(message)
+      end
+    end
+  end
+end

data/lib/jobi/config/rabbitmq.rb

@@ -0,0 +1,58 @@
+module Jobi
+  module Config
+    class Rabbitmq
+      attr_accessor :host, :port, :user, :pass, :vhost,
+                    :heartbeat, :automatically_recover,
+                    :network_recovery_interval, :threaded, :ssl,
+                    :continuation_timeout, :frame_max, :auth_mechanism
+
+      def initialize
+        setup_server_config
+        setup_network_config
+        setup_processing_config
+      end
+
+      def to_h
+        {
+          host: @host,
+          port: @port,
+          user: @user,
+          pass: @pass,
+          vhost: @vhost,
+          auth_mechanism: @auth_mechanism,
+          heartbeat: @heartbeat,
+          automatically_recover: @automatically_recover,
+          network_recovery_interval: @network_recovery_interval,
+          ssl: @ssl,
+          threaded: @threaded,
+          continuation_timeout: @continuation_timeout,
+          frame_max: @frame_max
+        }
+      end
+
+      private
+
+      def setup_server_config
+        @host = '127.0.0.1'
+        @port = '5672'
+        @user = 'guest'
+        @pass = 'guest'
+        @vhost = '/'
+        @auth_mechanism = 'PLAIN'
+      end
+
+      def setup_network_config
+        @heartbeat = :server
+        @automatically_recover = true
+        @network_recovery_interval = 5.0
+        @ssl = false
+      end
+
+      def setup_processing_config
+        @threaded = true
+        @continuation_timeout = 4000
+        @frame_max = 131_072
+      end
+    end
+  end
+end

data/lib/jobi/configuration.rb

@@ -0,0 +1,66 @@
+module Jobi
+  class Configuration
+    attr_accessor :log_file, :act_as_publisher, :act_as_consumer, :jobs
+    attr_writer :log_level
+    attr_reader :logger, :rabbitmq_config, :client
+
+    def initialize
+      setup_client
+      setup_log_config
+      setup_logger
+      setup_pub_sub_config
+      setup_jobs
+      rabbitmq
+    end
+
+    def log_level
+      case @log_level
+      when :info
+        Logger::INFO
+      when :warn
+        Logger::WARN
+      when :debug
+        Logger::DEBUG
+      end
+    end
+
+    def rabbitmq(options = {})
+      @rabbitmq_config ||= Jobi::Config::Rabbitmq.new
+      @client = :rabbitmq
+
+      options.keys.each do |key|
+        @rabbitmq_config.send("#{key}=", options[key])
+      end
+    end
+
+    def setup_logger
+      @logger = if @log_file
+                  Logger.new(@log_file)
+                else
+                  Logger.new(STDOUT)
+                end
+
+      @logger.level = @log_level
+    end
+
+    private
+
+    def setup_log_config
+      @log_level = :info
+      @log_file = nil
+    end
+
+    def setup_client
+      @client = :rabbitmq
+    end
+
+    def setup_pub_sub_config
+      @act_as_publisher = true
+      @act_as_consumer = true
+    end
+
+    def setup_jobs
+      @jobs = []
+    end
+  end
+end

data/lib/jobi/consumers/rabbitmq.rb

@@ -0,0 +1,26 @@
+require 'jobi/runner'
+require 'bunny'
+
+module Jobi
+  module Consumers
+    class Rabbitmq
+      def initialize(queue:, ack:)
+        @queue = queue
+        @ack = ack
+      end
+
+      def consume!
+        @queue.subscribe(manual_ack: @ack) do |delivery_info, metadata, payload|
+          Jobi::Runner.new(payload: payload).run
+          acknowledge!(delivery_info.delivery_tag) if @ack
+        end
+      end
+
+      private
+
+      def acknowledge!(delivery_tag)
+        @queue.channel.acknowledge(delivery_tag, false)
+      end
+    end
+  end
+end

data/lib/jobi/job.rb

@@ -0,0 +1,89 @@
+require 'jobi/utils'
+require 'jobi/message'
+
+module Jobi
+  class Job
+    class << self
+      include Utils
+
+      def options(queue_name:, ack: false, consumers: 5)
+        @queue_name = queue_name.to_s
+        @ack = ack
+        @consumers = consumers
+      end
+
+      def after_run(callback)
+        @after_run_callback = callback if callback
+      end
+
+      def run(**args)
+        return unless Jobi.publisher?
+
+        before_start(args)
+        start
+      rescue Error => e
+        Jobi.logger.error('Failed to process the job')
+        Jobi.logger.error(e)
+      end
+
+      def consume_messages
+        return unless Jobi.consumer?
+
+        join_queue
+
+        @consumer_threads = []
+        @consumers.times do
+          @consumer_threads << Thread.new { consumer.consume! }
+        end
+
+        @consumer_threads.join(&:join)
+      end
+
+      private
+
+      def before_start(args)
+        create_message(args: args)
+        log_job_info!
+      end
+
+      def start
+        join_queue
+        publish_message
+        @message.id
+      end
+
+      def consumer
+        class_const = constantize("Jobi::Consumers::#{Jobi.client_class_name}")
+        class_const.new(queue: @queue, ack: @ack)
+      end
+
+      def join_queue
+        @queue = Jobi.session
+                     .queue(name: @queue_name)
+      end
+
+      def publish_message
+        Jobi.session
+            .publish(
+              message: Marshal.dump(@message),
+              queue: @queue
+            )
+      end
+
+      def create_message(args:)
+        @message = Message.new(
+          job_class: self,
+          args: args,
+          after_run: @after_run_callback
+        )
+      end
+
+      def log_job_info!
+        Jobi.logger.info("A job has been started with id: [#{@message.id}]")
+        Jobi.logger.debug("Queue: '#{@queue_name}'")
+        Jobi.logger.debug("Args: #{@message.args}")
+        Jobi.logger.debug("Job class: '#{@message.job_class}'")
+      end
+    end
+  end
+end

data/lib/jobi/message.rb

@@ -0,0 +1,17 @@
+require 'jobi/utils'
+
+module Jobi
+  class Message
+    include Utils
+
+    attr_reader :id, :job_class, :args, :started_at, :after_run
+
+    def initialize(job_class:, args:, after_run: nil)
+      @id = generate_job_id
+      @job_class = job_class
+      @args = args
+      @started_at = Time.now.to_f
+      @after_run = after_run
+    end
+  end
+end

data/lib/jobi/runner.rb

@@ -0,0 +1,25 @@
+require 'jobi/utils'
+
+module Jobi
+  class Runner
+    include Utils
+
+    def initialize(payload:)
+      @message = Marshal.load(payload)
+    end
+
+    def run
+      job = @message.job_class.new(**@message.args)
+      job.run
+      job.send(@message.after_run) if @message.after_run
+
+      Jobi.logger.info("Completed in: #{job_duration}")
+    end
+
+    private
+
+    def job_duration
+      Time.now.to_f - @message.started_at
+    end
+  end
+end