asynchronic 3.0.1 → 4.0.1

data/lib/asynchronic/notifier/broadcaster.rb

@@ -8,23 +8,27 @@ module Asynchronic
       end
 
       def publish(pid, event, data=nil)
-        @broadcaster.publish DataStore::Key[pid][event], data
+        broadcaster.publish DataStore::Key[pid][event], data
       end
 
       def subscribe(pid, event, &block)
-        @broadcaster.subscribe DataStore::Key[pid][event] do |data|
+        broadcaster.subscribe DataStore::Key[pid][event] do |data|
           block.call data
         end
       end
 
       def unsubscribe(subscription_id)
-        @broadcaster.unsubscribe subscription_id
+        broadcaster.unsubscribe subscription_id
       end
 
       def unsubscribe_all
-        @broadcaster.unsubscribe_all
+        broadcaster.unsubscribe_all
       end
 
+      private
+
+      attr_reader :broadcaster
+
     end
   end
 end

data/lib/asynchronic/process.rb

@@ -13,11 +13,36 @@ module Asynchronic
 
     ATTRIBUTE_NAMES = [:type, :name, :queue, :status, :dependencies, :data, :result, :error, :connection_name] | TIME_TRACKING_MAP.values.uniq
 
+    AUTOMATIC_ABORTED_ERROR_MESSAGE = 'Automatic aborted before execution'
     CANCELED_ERROR_MESSAGE = 'Canceled'
     DEAD_ERROR_MESSAGE = 'Process connection broken'
 
     attr_reader :id
 
+    def self.create(environment, type, params={})
+      id = params.delete(:id) || SecureRandom.uuid
+
+      Asynchronic.logger.debug('Asynchronic') { "Created process #{type} - #{id} - #{params}" }
+
+      new(environment, id) do
+        self.type = type
+        self.name = (params.delete(:alias) || type).to_s
+        self.queue = params.delete(:queue) || type.queue || parent_queue
+        self.dependencies = Array(params.delete(:dependencies)) | Array(params.delete(:dependency)) | infer_dependencies(params)
+        self.params = params
+        self.data = {}
+        pending!
+      end
+    end
+
+    def self.all(environment)
+      environment.data_store.keys
+                            .select { |k| k.sections.count == 2 && k.match(/created_at$/) }
+                            .sort_by { |k| environment.data_store[k] }
+                            .reverse
+                            .map { |k| Process.new environment, k.remove_last }
+    end
+
     def initialize(environment, id, &block)
       @environment = environment
       @id = DataStore::Key[id]
@@ -83,9 +108,11 @@ module Asynchronic
     end
 
     def processes
-      data_store.scoped(:processes).keys.
-        select { |k| k.sections.count == 2 && k.match(/\|name$/) }.
-        sort.map { |k| Process.new environment, id[:processes][k.remove_last] }
+      data_store.scoped(:processes)
+                .keys
+                .select { |k| k.sections.count == 2 && k.match(/\|name$/) }
+                .sort
+                .map { |k| Process.new environment, id[:processes][k.remove_last] }
     end
 
     def parent
@@ -97,22 +124,20 @@ module Asynchronic
     end
 
     def real_error
-      return nil unless error
+      return nil if !aborted?
 
-      processes.each do |child|
-        return child.real_error if child.error
-      end
+      first_aborted_child = processes.select(&:aborted?).sort_by(&:finalized_at).first
 
-      error.message
+      first_aborted_child ? first_aborted_child.real_error : error.message
     end
 
     def dependencies
       return [] if parent.nil? || data_store[:dependencies].empty?
-      
+
       parent_processes = parent.processes.each_with_object({}) do |process, hash|
         hash[process.name] = process
       end
-      
+
       data_store[:dependencies].map { |d| parent_processes[d.to_s] }
     end
 
@@ -136,7 +161,7 @@ module Asynchronic
         wakeup_children
       end
       Asynchronic.logger.info('Asynchronic') { "Wakeup finalized #{type} (#{id})" }
-      
+
       parent.wakeup if parent && finalized?
     end
 
@@ -152,29 +177,6 @@ module Asynchronic
       self.data = self.data.merge key => value
     end
 
-    def self.create(environment, type, params={})
-      id = params.delete(:id) || SecureRandom.uuid
-
-      Asynchronic.logger.debug('Asynchronic') { "Created process #{type} - #{id} - #{params}" }
-
-      new(environment, id) do
-        self.type = type
-        self.name = (params.delete(:alias) || type).to_s
-        self.queue = params.delete(:queue) || type.queue || parent_queue
-        self.dependencies = Array(params.delete(:dependencies)) | Array(params.delete(:dependency)) | infer_dependencies(params)
-        self.params = params
-        self.data = {}
-        pending!
-      end
-    end
-
-    def self.all(environment)
-      environment.data_store.keys.
-        select { |k| k.sections.count == 2 && k.match(/created_at$/) }.
-        sort_by { |k| environment.data_store[k] }.reverse.
-        map { |k| Process.new environment, k.remove_last }
-    end
-
     private
 
     attr_reader :environment
@@ -195,10 +197,10 @@ module Asynchronic
 
     def status=(status)
       Asynchronic.logger.info('Asynchronic') { "#{status.to_s.capitalize} #{type} (#{id})" }
-      
+
       data_store[:status] = status
       data_store[TIME_TRACKING_MAP[status]] = Time.now if TIME_TRACKING_MAP.key? status
-      
+
       environment.notifier.publish id, :status_changed, status
       environment.notifier.publish id, :finalized if finalized?
     end
@@ -215,8 +217,8 @@ module Asynchronic
       end
     end
 
-    def abort!(exception=nil)
-      self.error = Error.new exception if exception
+    def abort!(exception)
+      self.error = Error.new exception
       aborted!
     end
 
@@ -224,13 +226,13 @@ module Asynchronic
       self.connection_name = Asynchronic.connection_name
 
       if root.aborted?
-        abort!
+        abort! AUTOMATIC_ABORTED_ERROR_MESSAGE
       else
         running!
         self.result = job.call
         waiting!
       end
-    
+
     rescue Exception => ex
       message = "Failed process #{type} (#{id})\n#{ex.class} #{ex.message}\n#{ex.backtrace.join("\n")}"
       Asynchronic.logger.error('Asynchronic') { message }

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.1'
+  VERSION = '4.0.1'
 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