asynchronic 3.0.3 → 4.0.0

data/lib/asynchronic/queue_engine/in_memory.rb

@@ -2,27 +2,25 @@ module Asynchronic
   module QueueEngine
     class InMemory
 
-      attr_reader :default_queue
-
       def initialize(options={})
-        @default_queue = options[:default_queue]
+        @options = options
         @queues ||= Hash.new { |h,k| h[k] = Queue.new }
       end
 
       def default_queue
-        @default_queue ||= Asynchronic.default_queue
+        @default_queue ||= options.fetch(:default_queue, Asynchronic.default_queue)
       end
 
       def [](name)
-        @queues[name]
+        queues[name]
       end
 
-      def queues
-        @queues.keys.map(&:to_sym)
+      def queue_names
+        queues.keys.map(&:to_sym)
       end
 
       def clear
-        @queues.clear
+        queues.clear
       end
 
       def listener
@@ -37,12 +35,16 @@ module Asynchronic
         [Asynchronic.connection_name]
       end
 
+      private
+
+      attr_reader :queues, :options
+
 
       class Queue
 
         extend Forwardable
 
-        def_delegators :@queue, :size, :empty?, :to_a
+        def_delegators :queue, :size, :empty?, :to_a
 
         def initialize
           @queue = []
@@ -50,13 +52,17 @@ module Asynchronic
         end
 
         def pop
-          @mutex.synchronize { @queue.shift }
+          mutex.synchronize { queue.shift }
         end
 
         def push(message)
-          @mutex.synchronize { @queue.push message }
+          mutex.synchronize { queue.push message }
         end
 
+        private
+
+        attr_reader :queue, :mutex
+
       end
 
 

data/lib/asynchronic/queue_engine/ost.rb

@@ -5,22 +5,22 @@ module Asynchronic
       attr_reader :redis, :default_queue
 
       def initialize(options={})
-        @redis = Redic.new(*Array(options[:redis]))
+        @redis = Asynchronic.establish_redis_connection options
         @default_queue = options.fetch(:default_queue, Asynchronic.default_queue)
         @queues ||= Hash.new { |h,k| h[k] = Queue.new k, redis }
         @keep_alive_thread = notify_keep_alive
       end
 
       def [](name)
-        @queues[name]
+        queues[name]
       end
 
-      def queues
-        (@queues.values.map(&:key) | redis.call!('KEYS', 'ost:*')).map { |q| q.to_s[4..-1].to_sym }
+      def queue_names
+        (queues.values.map(&:key) | redis.call!('KEYS', 'ost:*')).map { |q| q.to_s[4..-1].to_sym }
       end
 
       def clear
-        @queues.clear
+        queues.clear
         redis.call!('KEYS', 'ost:*').each { |k| redis.call!('DEL', k) }
       end
 
@@ -41,6 +41,8 @@ module Asynchronic
 
       private
 
+      attr_reader :queues
+
       def notify_keep_alive
         Thread.new do
           loop do

data/lib/asynchronic/queue_engine/synchronic.rb

@@ -5,7 +5,7 @@ module Asynchronic
       attr_reader :stubs
 
       def initialize(options={})
-        @environment = options[:environment]
+        @options = options
         @stubs = {}
       end
 
@@ -14,7 +14,7 @@ module Asynchronic
       end
 
       def environment
-        @environment ||= Asynchronic.environment
+        @environment ||= options.fetch(:environment, Asynchronic.environment)
       end
 
       def [](name)
@@ -22,7 +22,7 @@ module Asynchronic
       end
 
       def stub(job, &block)
-        @stubs[job] = block
+        stubs[job] = block
       end
 
       def asynchronic?
@@ -33,6 +33,10 @@ module Asynchronic
         [Asynchronic.connection_name]
       end
 
+      private
+
+      attr_reader :options
+
 
       class Queue
 
@@ -41,11 +45,11 @@ module Asynchronic
         end
 
         def push(message)
-          process = @engine.environment.load_process(message)
+          process = engine.environment.load_process(message)
 
-          if @engine.stubs[process.type]
+          if engine.stubs[process.type]
             job = process.job
-            block = @engine.stubs[process.type]
+            block = engine.stubs[process.type]
             process.define_singleton_method :job do
               MockJob.new job, process, &block
             end
@@ -54,6 +58,10 @@ module Asynchronic
           process.execute
         end
 
+        private
+
+        attr_reader :engine
+
       end
 
 
@@ -66,12 +74,16 @@ module Asynchronic
         end
 
         def call
-          @block.call @process
+          block.call process
         end
 
         def before_finalize
         end
 
+        private
+
+        attr_reader :process, :block
+
       end
 
     end

data/lib/asynchronic/version.rb

@@ -1,3 +1,3 @@
 module Asynchronic
-  VERSION = '3.0.3'
+  VERSION = '4.0.0'
 end

data/lib/asynchronic/worker.rb

@@ -1,24 +1,21 @@
 class Asynchronic::Worker
 
-  attr_reader :queue
-  attr_reader :queue_name
-  attr_reader :env
-  attr_reader :listener
+  attr_reader :queue, :queue_name, :environment, :listener
 
-  def initialize(queue_name, env)
+  def initialize(queue_name, environment)
     @queue_name = queue_name
-    @queue = env.queue_engine[queue_name]
-    @env = env
-    @listener = env.queue_engine.listener
+    @queue = environment.queue_engine[queue_name]
+    @environment = environment
+    @listener = environment.queue_engine.listener
   end
 
   def start
     Asynchronic.logger.info('Asynchronic') { "Starting worker of #{queue_name} (#{Process.pid})" }
 
     Signal.trap('QUIT') { stop }
-    
+
     listener.listen(queue) do |pid|
-      env.load_process(pid).execute
+      environment.load_process(pid).execute
     end
   end
 

data/spec/data_store/data_store_examples.rb

@@ -1,5 +1,11 @@
 module DataStoreExamples
-  
+
+  extend Minitest::Spec::DSL
+
+  after do
+    data_store.clear
+  end
+
   it 'Get/Set value' do
     data_store[:key] = 123
     data_store[:key].must_equal 123
@@ -32,8 +38,8 @@ module DataStoreExamples
     data_store.delete_cascade Asynchronic::DataStore::Key[:key_1]
 
     data_store.keys.sort.must_equal [
-      Asynchronic::DataStore::Key[:key_2], 
-      Asynchronic::DataStore::Key[:key_2][:key_2_1], 
+      Asynchronic::DataStore::Key[:key_2],
+      Asynchronic::DataStore::Key[:key_2][:key_2_1],
       Asynchronic::DataStore::Key[:key_2][:key_2_2]
     ]
   end
@@ -110,18 +116,20 @@ module DataStoreExamples
 
   it 'Synchronization' do
     sum = 0
-    threads = 1.upto(100).map do |i|
+
+    threads = 10.times.map do
       Thread.new do
-        data_store.synchronize('xxx') do
+        data_store.synchronize('lock_key') do
           temp = sum
-          sleep 0
+          sleep 0.01
           sum = temp + 1
         end
       end
     end
+
     threads.each(&:join)
-      
-    sum.must_equal 100
+
+    sum.must_equal threads.count
   end
-  
+
 end

data/spec/data_store/in_memory_spec.rb

@@ -1,6 +1,4 @@
 require 'minitest_helper'
-require_relative './data_store_examples'
-require_relative './lazy_value_examples'
 
 describe Asynchronic::DataStore::InMemory do
 

data/spec/data_store/key_spec.rb

@@ -56,5 +56,5 @@ describe Asynchronic::DataStore::Key do
     key.remove_last.must_equal 'foo|bar'
     key.remove_last(2).must_equal 'foo'
   end
-  
+
 end

data/spec/data_store/lazy_value_examples.rb

@@ -1,5 +1,7 @@
 module LazyValueExamples
 
+  extend Minitest::Spec::DSL
+
   def lazy_value(key)
     Asynchronic::DataStore::LazyValue.new data_store, key
   end
@@ -7,25 +9,25 @@ module LazyValueExamples
   it 'Get' do
     value = lazy_value :key
     value.must_be_nil
-    
-    data_store[:key] =  1
+
+    data_store[:key] = 1
     value.must_equal 1
   end
 
   it 'Reload' do
     value = lazy_value :key
 
-    data_store[:key] =  1
+    data_store[:key] = 1
     value.must_equal 1
 
-    data_store[:key] =  2
+    data_store[:key] = 2
     value.must_equal 1
     value.reload.must_equal 2
   end
 
   it 'Transparent proxy' do
     value = lazy_value :key
-    data_store[:key] =  1
+    data_store[:key] = 1
     value.must_equal 1
   end
 

data/spec/data_store/redis_spec.rb

@@ -1,17 +1,15 @@
 require 'minitest_helper'
-require_relative './data_store_examples'
-require_relative './lazy_value_examples'
 
 describe Asynchronic::DataStore::Redis do
 
   let(:data_store) { Asynchronic::DataStore::Redis.new :asynchronic_test }
 
-  after do
-    data_store.clear
-  end
-
   include DataStoreExamples
 
+  describe 'LazyValue' do
+    include LazyValueExamples
+  end
+
   it 'Safe deserialization' do
     SampleClass = Class.new
 
@@ -24,8 +22,4 @@ describe Asynchronic::DataStore::Redis do
     data_store[:instance].must_be_instance_of String
   end
 
-  describe 'LazyValue' do
-    include LazyValueExamples
-  end
-
 end

data/spec/expectations.rb

@@ -15,10 +15,10 @@ module MiniTest::Assertions
   def assert_be_initialized(process)
     process.must_be :pending?
     process.wont_be :finalized?
-    
+
     process.processes.must_be_empty
     process.error.must_be_nil
-    
+
     process.created_at.must_be_instance_of Time
     process.queued_at.must_be_nil
     process.started_at.must_be_nil

data/spec/facade_spec.rb

@@ -6,7 +6,7 @@ describe Asynchronic, 'Facade' do
     Asynchronic.environment.data_store.clear
     Asynchronic.environment.queue_engine.clear
   end
-  
+
   it 'Default queue' do
     Asynchronic.default_queue.must_equal :asynchronic_test
   end
@@ -40,7 +40,7 @@ describe Asynchronic, 'Facade' do
   end
 
   it 'List processes' do
-    ids = 3.times.map do 
+    ids = 3.times.map do
       process = Asynchronic.environment.create_process SequentialJob
       process.id
     end
@@ -51,7 +51,7 @@ describe Asynchronic, 'Facade' do
 
   it 'Enqueue' do
     id = BasicJob.enqueue input: 100
-    
+
     Asynchronic.environment.tap do |env|
       process = env.load_process id
       process.type.must_equal BasicJob

data/spec/jobs.rb

@@ -9,8 +9,8 @@ class SequentialJob < Asynchronic::Job
 
   def call
     async Step1, input: params[:input]
-    
-    async Step2, dependency: Step1, 
+
+    async Step2, dependency: Step1,
                  input: params[:input]
 
     nil
@@ -32,7 +32,7 @@ end
 
 
 class GraphJob < Asynchronic::Job
-  
+
   def call
     async Sum, input: params[:input]
 
@@ -113,13 +113,13 @@ class AliasJob < Asynchronic::Job
   def call
     async Write, alias: :word_1,
                  text: 'Take'
-    
-    async Write, alias: :word_2, 
-                 text: 'it', 
+
+    async Write, alias: :word_2,
+                 text: 'it',
                  prefix: result(:word_1)
-    
-    async Write, alias: :word_3, 
-                 text: 'easy', 
+
+    async Write, alias: :word_3,
+                 text: 'easy',
                  prefix: result(:word_2)
 
     result :word_3
@@ -402,4 +402,4 @@ class BeforeFinalizeExceptionOnAbortedJob < Asynchronic::Job
   def before_finalize
     raise 'Before finalize error'
   end
-end
+end