tennis-jobs 0.3.1 → 0.4.0

data/tennis-jobs.gemspec

@@ -4,12 +4,12 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "tennis-jobs"
-  spec.version       = "0.3.1"
+  spec.version       = "0.4.0"
   spec.authors       = ["Nicolas ZERMATI"]
   spec.email         = ["nicoolas25@gmail.com"]
 
-  spec.summary       = %q{A small background job library on top of sneakers.}
-  spec.description   = %q{A small background job library on top of sneakers.}
+  spec.summary       = %q{A backend agnostic, actor based, background jobs library.}
+  spec.description   = %q{A backend agnostic, actor based, background jobs library.}
   spec.homepage      = "https://github.com/nicoolas25/tennis"
   spec.license       = "MIT"
 
@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "sneakers"
+  spec.add_runtime_dependency "celluloid"
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: tennis-jobs
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Nicolas ZERMATI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-04 00:00:00.000000000 Z
+date: 2015-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sneakers
+  name: celluloid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -122,7 +122,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A small background job library on top of sneakers.
+description: A backend agnostic, actor based, background jobs library.
 email:
 - nicoolas25@gmail.com
 executables:
@@ -139,19 +139,22 @@ files:
 - README.markdown
 - Rakefile
 - bin/tennis
-- examples/deferable.rb
-- examples/example.rb
-- examples/serializer.rb
+- examples/async_sum.rb
 - lib/tennis.rb
+- lib/tennis/action.rb
+- lib/tennis/actor.rb
+- lib/tennis/backend/abstract.rb
+- lib/tennis/backend/memory.rb
+- lib/tennis/backend/serializer.rb
+- lib/tennis/backend/task.rb
 - lib/tennis/cli.rb
 - lib/tennis/configuration.rb
-- lib/tennis/serializer/generic.rb
-- lib/tennis/worker/deferable.rb
-- lib/tennis/worker/deferable/action.rb
-- lib/tennis/worker/generic.rb
-- lib/tennis/worker/generic/before_hook.rb
-- lib/tennis/worker/generic/options.rb
-- lib/tennis/worker/generic/serialize.rb
+- lib/tennis/exceptions.rb
+- lib/tennis/fetcher.rb
+- lib/tennis/job.rb
+- lib/tennis/launcher.rb
+- lib/tennis/worker.rb
+- lib/tennis/worker_pool.rb
 - tennis-jobs.gemspec
 homepage: https://github.com/nicoolas25/tennis
 licenses:
@@ -173,8 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: A small background job library on top of sneakers.
+summary: A backend agnostic, actor based, background jobs library.
 test_files: []

data/examples/deferable.rb

@@ -1,46 +0,0 @@
-#
-# Create a client or a worker showing the serialization process.
-#
-# To run this example you should start a worker, then a client in a separate
-# shell. Of course you'll also need a running RabbitMQ server.
-#
-# Use RABBITMQ_URL environment variable if you need to customize the RabbitMQ
-# address.
-#
-
-$LOAD_PATH.unshift("./lib")
-
-require "tennis"
-
-require_relative "example"
-
-class Model
-  include Tennis::Worker::Deferable
-
-  attr_reader :id
-
-  def initialize(id)
-    @id = id
-  end
-
-  def method(numbers)
-    puts "At #{Time.now}, Model##{id} run method with #{numbers.inspect}\n"
-  end
-
-  # Usually the ORM provides this method. Here we're just faking it.
-  def self.find(id)
-    new(id)
-  end
-
-  # Usually the ORM provides this method. Here we're faking it too.
-  def attributes
-    { id: @id }
-  end
-end
-
-Example.new(__FILE__, Model).run do |i|
-  array = Array.new(5) { 1 + rand(5) }
-  print "Press enter to enqueue a random array..." ; gets
-  puts "Calling <Model##{i}>.method(#{array.inspect})"
-  Model.new(i).defer.method(array)
-end

data/examples/example.rb

@@ -1,52 +0,0 @@
-require "logger"
-require "optparse"
-require "sneakers/runner"
-
-class Example
-  def initialize(filename, klass)
-    @filename = filename
-    @klass = klass
-  end
-
-  def run(&client_code)
-    configure_workers
-    parse_options
-    if @options[:client]
-      start_client(client_code)
-    elsif @options[:worker]
-      start_worker
-    end
-  end
-
-  protected
-
-  def configure_workers
-    Tennis.configure do |config|
-      config.async = true
-      config.exchange = "example"
-      config.workers = 1
-      config.logger = Logger.new(STDOUT)
-      config.logger.level = Logger::WARN
-    end
-  end
-
-  def start_client(block, i = 1)
-    block.call(i)
-    start_client(block, i + 1)
-  rescue Interrupt
-    puts "Exiting the client"
-  end
-
-  def start_worker
-    Sneakers::Runner.new([@klass.worker]).run
-  end
-
-  def parse_options
-    @options = {}
-    OptionParser.new do |opts|
-      opts.banner = "Usage: #{@filename}"
-      opts.on("-c", "--client", "Run the client") { @options[:client] = true }
-      opts.on("-w", "--worker", "Run the worker") { @options[:worker] = true }
-    end.parse!
-  end
-end

data/examples/serializer.rb

@@ -1,37 +0,0 @@
-#
-# Create a client or a worker showing the serialization process.
-#
-# To run this example you should start a worker, then a client in a separate
-# shell. Of course you'll also need a running RabbitMQ server.
-#
-# Use RABBITMQ_URL environment variable if you need to customize the RabbitMQ
-# address.
-#
-
-$LOAD_PATH.unshift("./lib")
-
-require "json"
-require "tennis"
-
-require_relative "example"
-
-class SumWorker
-  include Tennis::Worker::Generic
-
-  serialize loader: ->(message){ JSON.parse(message) },
-            dumper: ->(message){ JSON.generate(message) }
-
-  work do |int_array|
-    sum = int_array.inject(0, &:+)
-    puts "At #{Time.now} I received an array. Sum of its elements is: #{sum}"
-    ack!
-  end
-end
-
-Example.new(__FILE__, SumWorker).run do
-  array = Array.new(5) { 1 + rand(5) }
-  print "Press enter to enqueue a random array..." ; gets
-  puts "Sending #{array.inspect} to the #{SumWorker::Worker.queue_name} queue!"
-  SumWorker.send_work(array)
-end
-

data/lib/tennis/worker/deferable.rb

@@ -1,55 +0,0 @@
-module Tennis
-  module Worker
-    module Deferable
-
-      autoload :Action, "tennis/worker/deferable/action"
-
-      def self.included(base)
-        base.extend DSL
-        base.include Worker::Generic
-        base.serialize Serializer::Generic.new
-        define_work_broker(base)
-      end
-
-      def self.define_work_broker(base)
-        base.work do |message|
-          begin
-            receiver, method, arguments = message
-            result = receiver.__send__(method, *arguments)
-            instance_exec(result, &base._on_success)
-          rescue => exception
-            instance_exec(exception, message, &base._on_error)
-          end
-        end
-      end
-
-      def defer
-        Action.new(self.class, self)
-      end
-
-      module DSL
-
-        def defer
-          Action.new(self, self)
-        end
-
-        def on_error(&block)
-          @_on_error = block
-        end
-
-        def on_success(&block)
-          @_on_success = block
-        end
-
-        def _on_error
-          @_on_error || ->(_, _){ reject! }
-        end
-
-        def _on_success
-          @_on_success || ->(_){ ack! }
-        end
-
-      end
-    end
-  end
-end

data/lib/tennis/worker/deferable/action.rb

@@ -1,25 +0,0 @@
-class Tennis::Worker::Deferable::Action
-  def initialize(worker_class, receiver)
-    @worker_class = worker_class
-    @receiver = receiver
-    _create_methods!
-  end
-
-  private
-
-  def _create_methods!
-    _methods.each do |method|
-      self.define_singleton_method(method) do |*arguments|
-        @worker_class.send_work([@receiver, method, arguments])
-      end
-    end
-  end
-
-  def _methods
-    if @receiver.kind_of?(Class)
-      @receiver.methods(false).map(&:to_s)
-    else
-      @receiver.class.instance_methods(false).map(&:to_s)
-    end
-  end
-end

data/lib/tennis/worker/generic.rb

@@ -1,58 +0,0 @@
-module Tennis
-  module Worker
-    module Generic
-
-      autoload :BeforeHook, "tennis/worker/generic/before_hook"
-      autoload :Serialize,  "tennis/worker/generic/serialize"
-      autoload :Options,    "tennis/worker/generic/options"
-
-      def self.included(base)
-        base.extend BeforeHook
-        base.extend Serialize
-        base.extend Options
-        base.extend DSL
-        base.worker = Class.new do
-          @@parent = base
-
-          include Sneakers::Worker
-          from_queue @@parent.name
-
-          def work(message)
-            message = @@parent._apply_serializer(:load, message)
-            @@parent._process_before_hooks(message, self)
-            instance_exec(message, &@@parent._work)
-          end
-        end
-      end
-
-      module DSL
-
-        attr_accessor :worker
-
-        def work(&block)
-          @_work = block
-        end
-
-        def _work
-          @_work ||= ->(_){ ack! }
-        end
-
-        def send_work(message)
-          message = _apply_serializer(:dump, message)
-          if Tennis.config.async
-            publisher_opts = worker.queue_opts.select do |opt_name, _|
-              opt_name == :exchange ||
-              opt_name == :exchange_type
-            end
-            publisher = Sneakers::Publisher.new(publisher_opts)
-            publisher.publish(message, to_queue: worker.queue_name)
-            publisher.instance_variable_get(:@bunny).close
-          else
-            worker.new.work(message)
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/tennis/worker/generic/before_hook.rb

@@ -1,17 +0,0 @@
-module Tennis::Worker::Generic::BeforeHook
-  def before(&block)
-    if block_given?
-      _before_hooks << block
-    end
-  end
-
-  def _process_before_hooks(message, worker)
-    _before_hooks.each do |hook|
-      hook.call(message, worker)
-    end
-  end
-
-  def _before_hooks
-    @_before_hooks ||= []
-  end
-end

data/lib/tennis/worker/generic/options.rb

@@ -1,19 +0,0 @@
-module Tennis::Worker::Generic::Options
-  SNEAKER_QUEUE_OPTIONS = %i(exchange).freeze
-
-  def set_option(symbol, value)
-    if symbol == :queue_name
-      worker.from_queue(value, worker.queue_opts)
-    else
-      options[symbol] = value
-      if SNEAKER_QUEUE_OPTIONS.include?(symbol)
-        worker.queue_opts[symbol] = value
-      end
-    end
-  end
-
-  def options
-    @_options ||= {}
-  end
-end
-

data/lib/tennis/worker/generic/serialize.rb

@@ -1,26 +0,0 @@
-module Tennis::Worker::Generic::Serialize
-  def serialize(object = nil, loader: nil,  dumper: nil)
-    if object
-      _serializers[:load] = object if object.respond_to?(:load)
-      _serializers[:dump] = object if object.respond_to?(:dump)
-    else
-      _serializers[:load] = loader if loader
-      _serializers[:dump] = dumper if dumper
-    end
-  end
-
-  def _apply_serializer(serializer_kind, message)
-    serializer = _serializers[serializer_kind]
-    if serializer.kind_of?(Proc)
-      serializer.call(message)
-    elsif serializer.respond_to?(serializer_kind)
-      serializer.__send__(serializer_kind, message)
-    else
-      fail "Unexpected (de)serializer, it must be a Proc or respond to ##{kind}"
-    end
-  end
-
-  def _serializers
-    @_serializers ||= Hash.new(->(message){ message })
-  end
-end