batch_reactor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15dc90fa2f1e38647ea6e975cb258274f4d51573
+  data.tar.gz: 4b4ec60ee51726b1c865274d7c7e6629e2fa3235
+SHA512:
+  metadata.gz: a17b3a124b8556aea468dd265ac40de1bdc7f805ab39aa400a0599bb520df6f562da6ff5cf76d55b1a6e8ef2a901742e629f0c3a3f15323b5a0d53bdd9cadad6
+  data.tar.gz: c98f2c55832fc30d70dfae41ecfd06a86c3aeb44a5dc3f2a53577eab55a33fd9a96fee2004d7f74ac03be6ac37321c2e9a8a9954d3a2506135ca6c171ec191fa

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2014-2015 Thomas RM Rogers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,17 @@
+# batch_reactor
+
+## Copyright
+
+Copyright 2015 Thomas Rogers.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+
+
+
+
+

data/lib/batch_reactor/reactor.rb

@@ -0,0 +1,126 @@
+module BatchReactor
+  class Reactor
+    include MonitorMixin
+    extend Forwardable
+
+    def initialize(options, &yield_batch_callback)
+      @yield_batch_callback = yield_batch_callback
+      @front_buffer = []
+      @back_buffer = []
+      @stopping_promise = Ione::Promise.new
+      @stopped_promise = Ione::Promise.new
+      @max_batch_size = options.fetch(:max_batch_size) { 100 }
+      @no_work_backoff = options.fetch(:no_work_backoff) { 0.1 }
+      super()
+    end
+
+    def start
+      return @started_promise.future if @started_promise
+
+      @started_promise = Ione::Promise.new
+      Thread.start do
+        @started_promise.fulfill(self)
+
+        last_batch_future = Ione::Future.resolved(nil)
+        until @stopping
+          swap_buffers if needs_work?
+          next if no_work?
+          last_batch_future = process_batch
+        end
+
+        last_batch_future.on_complete { |_, _| shutdown }
+      end
+      @started_promise.future
+    end
+
+    def stop
+      @stopping = true
+      @stopped_promise.future
+    end
+
+    def perform_within_batch(&block)
+      promise = Ione::Promise.new
+      if @stopping_promise.future.resolved?
+        promise.fail(StandardError.new('Reactor stopped!'))
+      else
+        synchronize { @back_buffer << Work.new(block, promise) }
+      end
+      promise.future
+    end
+
+    private
+
+    def_delegator :@front_buffer, :empty?, :needs_work?
+
+    Work = Struct.new(:proc, :promise, :result)
+
+    def swap_buffers
+      synchronize do
+        temp_buffer = @front_buffer
+        @front_buffer = @back_buffer
+        @back_buffer = temp_buffer
+      end
+    end
+
+    def no_work?
+      if @front_buffer.empty?
+        sleep @no_work_backoff
+        true
+      end
+    end
+
+    def process_batch
+      buffer = @front_buffer.slice!(0...@max_batch_size)
+      batch_future = create_batch(buffer)
+      batch_future.on_complete do |_, error|
+        error ? handle_failure(buffer, error) : handle_success(buffer)
+      end
+      batch_future
+    end
+
+    def create_batch(buffer)
+      @yield_batch_callback.call { |batch| perform_work(batch, buffer) }
+    end
+
+    def perform_work(batch, buffer)
+      buffer.each { |work| work.result = work.proc.call(batch) }
+    end
+
+    def handle_success(buffer)
+      buffer.each do |work|
+        result = work.result
+        if result.respond_to?(:on_complete)
+          handle_result_future(result, work)
+        else
+          work.promise.fulfill(result)
+        end
+      end
+    end
+
+    def handle_result_future(result, work)
+      result.on_complete do |value, error|
+        error ? work.promise.fail(error) : work.promise.fulfill(value)
+      end
+    end
+
+    def handle_failure(buffer, error)
+      buffer.each { |work| work.promise.fail(error) }
+    end
+
+    def shutdown
+      @stopping_promise.fulfill(self)
+
+      futures = []
+      finish_remaining_work(futures)
+      swap_buffers
+      finish_remaining_work(futures)
+
+      Ione::Future.all(futures).on_complete { |_, _| @stopped_promise.fulfill(self) }
+    end
+
+    def finish_remaining_work(futures)
+      futures << process_batch until @front_buffer.empty?
+    end
+
+  end
+end

data/lib/batch_reactor/reactor_cluster.rb

@@ -0,0 +1,30 @@
+module BatchReactor
+  class ReactorCluster
+
+    def initialize(count, options, &batch_callback)
+      @reactors = count.times.map do |index|
+        Reactor.new(options) { |&block| batch_callback.call(index, &block) }
+      end
+    end
+
+    def define_partitioner(&partitioner_callback)
+      @partitioner_callback = partitioner_callback
+    end
+
+    def start
+      futures = @reactors.map(&:start)
+      Ione::Future.all(futures)
+    end
+
+    def stop
+      futures = @reactors.map(&:stop)
+      Ione::Future.all(futures)
+    end
+
+    def perform_within_batch(key, &block)
+      partition = @partitioner_callback.call(key)
+      @reactors[partition].perform_within_batch(&block)
+    end
+
+  end
+end

data/lib/batch_reactor.rb

@@ -0,0 +1,2 @@
+require 'batch_reactor/reactor'
+require 'batch_reactor/reactor_cluster'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: batch_reactor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Thomas RM Rogers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ione
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: |-
+  A reactor pattern batching system for Ruby.
+  It provides simple functionality for batching work in background thread.
+  Also adds simple but powerful work partitioning behaviour
+email: thomasrogers03@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/batch_reactor.rb
+- lib/batch_reactor/reactor.rb
+- lib/batch_reactor/reactor_cluster.rb
+homepage: https://www.github.com/thomasrogers03/batch_reactor
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A reactor pattern batching system for Ruby
+test_files: []