beez 0.1.0

data/lib/beez/configurable.rb

@@ -0,0 +1,13 @@
+require 'beez/configuration'
+
+module Beez
+  module Configurable
+    def config
+      @config ||= ::Beez::Configuration.new
+    end
+
+    def configure
+      yield config if block_given?
+    end
+  end
+end

data/lib/beez/configuration.rb

@@ -0,0 +1,14 @@
+module Beez
+  class Configuration
+
+    attr_accessor :env, :logger, :require, :timeout, :zeebe_url
+
+    def initialize
+      @env = ENV["APP_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      @logger = Logger.new($stdout)
+      @require = "."
+      @timeout = 30
+      @zeebe_url = ENV['ZEEBE_URL'] || 'localhost:26500'
+    end
+  end
+end

data/lib/beez/launcher.rb

@@ -0,0 +1,35 @@
+require 'beez/supervisor'
+
+module Beez
+  class Launcher
+
+    attr_reader :supervisor
+
+    def initialize
+      @supervisor = ::Beez::Supervisor.new
+    end
+
+    # Starts the supervisor and job processors.
+    def start
+      supervisor.start
+    end
+
+    # Tells the supervisor to stop processing any more jobs.
+    def quiet
+      supervisor.quiet
+    end
+
+    # Tells the supervisor to stop job processors. This method blocks until
+    # all processors are complete and stopped. It can take up to configurable
+    # timeout.
+    def stop
+      supervisor.stop
+    end
+
+    private
+
+    def client
+      ::Beez.client
+    end
+  end
+end

data/lib/beez/loggable.rb

@@ -0,0 +1,15 @@
+module Beez
+  module Loggable
+    def logger
+      @logger || setup_logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def setup_logger
+      @logger = Beez.config.logger
+    end
+  end
+end

data/lib/beez/processor.rb

@@ -0,0 +1,103 @@
+module Beez
+  class Processor
+
+    attr_reader :client, :worker_class, :busy_count, :timer
+
+    def initialize(client: ::Beez.client, worker_class:)
+      @client = client
+      @worker_class = worker_class
+      @busy_count = ::Concurrent::AtomicFixnum.new(0)
+      @timer = ::Concurrent::TimerTask.new(
+        run_now: true,
+        execution_interval: worker_poll_interval,
+        timeout_interval: worker_timeout
+      ) { run }
+    end
+
+    def start
+      timer.execute
+      self
+    end
+
+    def stop
+      timer.shutdown
+      self
+    end
+
+    def should_activate_jobs?
+      busy_count.value <= worker_max_jobs_to_activate
+    end
+
+    private
+
+    def run
+      fetch if should_activate_jobs?
+    end
+
+    def fetch
+      activate_jobs_request.each do |response|
+        busy_count.increment(response.jobs.count)
+        response.jobs.each do |job|
+          ::Concurrent::Future.execute do
+            process(job)
+          end
+        end
+      end
+    end
+
+    def process(job)
+      worker = worker_class.new(client)
+      begin
+        worker.process(job)
+        worker.complete_job(job)
+      rescue => exception
+        worker.fail_job(job, reason: exception.message)
+        raise exception
+      ensure
+        busy_count.decrement
+      end
+    end
+
+    def activate_jobs_request
+      client.activate_jobs(
+        type: worker_type,
+        worker: worker_name,
+        timeout: worker_timeout * 1000,
+        maxJobsToActivate: max_jobs_to_activate,
+        fetchVariable: worker_variables_to_fetch,
+      )
+    end
+
+    def worker_type
+      worker_class.get_type
+    end
+
+    def worker_name
+      worker_class.get_name
+    end
+
+    def worker_max_jobs_to_activate
+      worker_class.get_max_jobs_to_activate
+    end
+
+    def worker_timeout
+      worker_class.get_timeout
+    end
+
+    def worker_variables_to_fetch
+      worker_class.get_variables_to_fetch
+    end
+
+    def worker_poll_interval
+      worker_class.get_poll_interval
+    end
+
+    def max_jobs_to_activate
+      worker_max_jobs_to_activate - busy_count.value
+    end
+
+    def logger
+      ::Beez.logger
+    end
+  end
+end

data/lib/beez/rails.rb

@@ -0,0 +1,29 @@
+module Beez
+  class Rails < ::Rails::Engine
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.reloader.wrap do
+          yield
+        end
+      end
+
+      def inspect
+        "#<Beez::Rails::Reloader @app=#{@app.class.name}>"
+      end
+    end
+
+    # This hook happens after all initializers are run, just before returning
+    # from config/environment.rb back to beez/cli.rb.
+    #
+    # None of this matters on the client-side, only within the Beez process itself.
+    config.after_initialize do
+      Beez.configure_server do |_|
+        Beez.options[:reloader] = Beez::Rails::Reloader.new
+      end
+    end
+  end
+end

data/lib/beez/supervisor.rb

@@ -0,0 +1,38 @@
+require 'beez/processor'
+
+module Beez
+  class Supervisor
+
+    def initialize
+      @processors = []
+    end
+
+    def start
+      @processors = workers.map do |worker_class|
+        processor = ::Beez::Processor.new(worker_class: worker_class)
+        processor.start
+      end
+    end
+
+    def quiet
+      logger.info "Terminating workers"
+      @processors.each(&:stop)
+    end
+
+    def stop(timeout: ::Beez.config.timeout)
+      quiet
+      logger.info "Pausing #{timeout}s to allow workers to finish..."
+      sleep timeout
+    end
+
+    private
+
+    def workers
+      ::Beez.workers.to_a
+    end
+
+    def logger
+      ::Beez.logger
+    end
+  end
+end

data/lib/beez/version.rb

@@ -0,0 +1,3 @@
+module Beez
+  VERSION = '0.1.0'.freeze
+end

data/lib/beez/worker.rb

@@ -0,0 +1,163 @@
+require 'json'
+
+module Beez
+  module Worker
+    attr_accessor :client, :type, :max_jobs_to_activate, :poll_interval, :timeout, :variables
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      Beez.register_worker(base)
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    def complete_job(job, variables: {})
+      logger.info "Completed processing job #{job.type} #{job.key}"
+      client.complete_job(
+        jobKey: job.key,
+        variables: Hash(variables).to_json,
+      )
+    end
+
+    def fail_job(job, reason: "")
+      logger.error "Failed processing job #{job.type} #{job.key}: #{reason}"
+      client.fail_job(
+        jobKey: job.key,
+        retries: job.retries - 1,
+        errorMessage: reason,
+      )
+    rescue => e
+      logger.error e.message
+    end
+
+    def logger
+      ::Beez.logger
+    end
+
+    module ClassMethods
+      # Sets the type of service task the worker should subscribe to.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Beez::Worker
+      #     type "some-service-task-type"
+      #   end
+      #
+      # @param [String] type
+      # @return [String]
+      def type(type)
+        @type = type
+      end
+
+      # Returns the type of service task the worker should subscribe to.
+      #
+      # @return [String]
+      def get_type
+        @type
+      end
+
+      # Sets the maximum number of jobs to send to the worker for processing at once.
+      # As jobs get completed by the worker, more jobs will be sent to the worker
+      # but always within this limit.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Beez::Worker
+      #     max_jobs_to_activate 5
+      #   end
+      #
+      # @param [Integer] max_jobs_to_activate
+      # @return [Integer]
+      def max_jobs_to_activate(max_jobs_to_activate)
+        @max_jobs_to_activate = max_jobs_to_activate
+      end
+
+      # Returns the maximum number of jobs to send to the worker for processing at once.
+      # As jobs get completed by the worker, more jobs will be sent to the worker
+      # but always within this limit.
+      #
+      # @return [Integer]
+      def get_max_jobs_to_activate
+        @max_jobs_to_activate || 1
+      end
+
+      # Sets the interval duration in seconds between polls to the broker.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Beez::Worker
+      #     poll_interval 5
+      #   end
+      #
+      # @param [Integer] poll_interval
+      # @return [Integer]
+      def poll_interval(poll_interval)
+        @poll_interval = poll_interval
+      end
+
+      # Returns the interval duration in seconds between polls to the broker.
+      #
+      # @return [Integer]
+      def get_poll_interval
+        @poll_interval || 5
+      end
+
+      # Sets the time in seconds the worker has to process the job before
+      # the broker consider it as expired and can schedule it to another worker.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Beez::Worker
+      #     timeout 30
+      #   end
+      #
+      # @param [Integer] timeout
+      # @return [Integer]
+      def timeout(timeout)
+        @timeout = timeout
+      end
+
+      # Returns the time in seconds the worker has to process the job before
+      # the broker consider it as expired and can schedule it to another worker.
+      #
+      # @return [Integer]
+      def get_timeout
+        @timeout || 30
+      end
+
+      # Sets the worker's variables to fetch from the broker when polling for new
+      # jobs.
+      #
+      # @example
+      #   class MyWorker
+      #     include ::Beez::Worker
+      #     variables [:foo, :bar]
+      #   end
+      #
+      # @param [Array<String, Symbol>] variables
+      # @return [Array<String, Symbol>]
+      def variables(variables)
+        @variables = variables
+      end
+
+      # Returns the worker's variables to fetch from the broker when polling for new
+      # jobs.
+      #
+      # @return [Array<String, Symbol>]
+      def get_variables_to_fetch
+        @variables.to_a
+      end
+
+      # Returns the worker's name.
+      #
+      # @return [String]
+      def get_name
+        name = self.name.gsub(/::/, ':')
+        name.gsub!(/([^A-Z:])([A-Z])/) { "#{$1}_#{$2}" }
+        name.downcase
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: beez
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pierre-Louis Gottfrois
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeebe-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Simple, efficient ruby workers for Zeebe business processes.
+email:
+- pierrelouis.gottfrois@gmail.com
+executables:
+- beez
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- beez.gemspec
+- bin/console
+- bin/setup
+- bpmn/order-process.bpmn
+- examples/workers.rb
+- exe/beez
+- lib/beez.rb
+- lib/beez/cli.rb
+- lib/beez/client.rb
+- lib/beez/configurable.rb
+- lib/beez/configuration.rb
+- lib/beez/launcher.rb
+- lib/beez/loggable.rb
+- lib/beez/processor.rb
+- lib/beez/rails.rb
+- lib/beez/supervisor.rb
+- lib/beez/version.rb
+- lib/beez/worker.rb
+homepage: https://github.com/gottfrois/beez
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/gottfrois/beez
+  source_code_uri: https://github.com/gottfrois/beez
+  changelog_uri: https://github.com/gottfrois/beez/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.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: Simple, efficient ruby workers for Zeebe business processes.
+test_files: []