asynchronic 2.0.1 → 4.0.0

data/lib/asynchronic/job.rb

@@ -1,18 +1,6 @@
 module Asynchronic
   class Job
 
-    def initialize(process)
-      @process = process
-    end
-
-    def params
-      @process.params
-    end
-
-    def result(reference)
-      @process[reference].result
-    end
-
     def self.queue(name=nil)
       name ? @queue = name : @queue
     end
@@ -23,6 +11,18 @@ module Asynchronic
       process.id
     end
 
+    def initialize(process)
+      @process = process
+    end
+
+    def params
+      process.params
+    end
+
+    def result(reference)
+      process[reference].result
+    end
+
     private
 
     attr_reader :process

data/lib/asynchronic/notifier/broadcaster.rb

@@ -0,0 +1,34 @@
+module Asynchronic
+  module Notifier
+    class Broadcaster
+
+      def initialize(options={})
+        options[:logger] ||= Asynchronic.logger
+        @broadcaster = ::Broadcaster.new options
+      end
+
+      def publish(pid, event, data=nil)
+        broadcaster.publish DataStore::Key[pid][event], data
+      end
+
+      def subscribe(pid, event, &block)
+        broadcaster.subscribe DataStore::Key[pid][event] do |data|
+          block.call data
+        end
+      end
+
+      def unsubscribe(subscription_id)
+        broadcaster.unsubscribe subscription_id
+      end
+
+      def unsubscribe_all
+        broadcaster.unsubscribe_all
+      end
+
+      private
+
+      attr_reader :broadcaster
+
+    end
+  end
+end

data/lib/asynchronic/notifier/in_memory.rb

@@ -0,0 +1,33 @@
+module Asynchronic
+  module Notifier
+    class InMemory
+
+      def publish(pid, event, data=nil)
+        subscriptions[DataStore::Key[pid][event]].each_value do |block|
+          block.call data
+        end
+      end
+
+      def subscribe(pid, event, &block)
+        SecureRandom.uuid.tap do |subscription_id|
+          subscriptions[DataStore::Key[pid][event]][subscription_id] = block
+        end
+      end
+
+      def unsubscribe(subscription_id)
+        subscriptions.each_value { |s| s.delete subscription_id }
+      end
+
+      def unsubscribe_all
+        subscriptions.clear
+      end
+
+      private
+
+      def subscriptions
+        @subscriptions ||= Hash.new { |h,k| h[k] = {} }
+      end
+
+    end
+  end
+end

data/lib/asynchronic/process.rb

@@ -13,10 +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]
@@ -51,6 +77,10 @@ module Asynchronic
       (running? && !connected?) || processes.any?(&:dead?)
     end
 
+    def abort_if_dead
+      abort! DEAD_ERROR_MESSAGE if dead?
+    end
+
     def destroy
       data_store.delete_cascade
     end
@@ -78,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
@@ -92,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
 
@@ -131,7 +161,7 @@ module Asynchronic
         wakeup_children
       end
       Asynchronic.logger.info('Asynchronic') { "Wakeup finalized #{type} (#{id})" }
-      
+
       parent.wakeup if parent && finalized?
     end
 
@@ -147,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
@@ -190,8 +197,12 @@ 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
 
     STATUSES.each do |status|
@@ -206,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
 
@@ -215,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 }
@@ -258,6 +269,9 @@ module Asynchronic
 
     def connected?
       connection_name && environment.queue_engine.active_connections.include?(connection_name)
+    rescue => ex
+      Asynchronic.logger.error('Asynchronic') { "#{ex.message}\n#{ex.backtrace.join("\n")}" }
+      true
     end
 
   end

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,23 +5,23 @@ 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
-        redis.call('KEYS', 'ost:*').each { |k| redis.call('DEL', k) }
+        queues.clear
+        redis.call!('KEYS', 'ost:*').each { |k| redis.call!('DEL', k) }
       end
 
       def listener
@@ -33,17 +33,20 @@ module Asynchronic
       end
 
       def active_connections
-        redis.call('CLIENT', 'LIST').split("\n").map do |connection_info|
-          connection_info.split(' ').detect { |a| a.match(/name=/) }[5..-1]
-        end.uniq.reject(&:empty?)
+        redis.call!('CLIENT', 'LIST').split("\n").map do |connection_info|
+          name_attr = connection_info.split(' ').detect { |a| a.match(/name=/) }
+          name_attr ? name_attr[5..-1] : nil
+        end.uniq.compact.reject(&:empty?)
       end
 
       private
 
+      attr_reader :queues
+
       def notify_keep_alive
         Thread.new do
           loop do
-            redis.call 'CLIENT', 'SETNAME', Asynchronic.connection_name
+            redis.call! 'CLIENT', 'SETNAME', Asynchronic.connection_name
             sleep Asynchronic.keep_alive_timeout
           end
         end
@@ -58,11 +61,11 @@ module Asynchronic
         end
 
         def pop
-          redis.call 'RPOP', key
+          redis.call! 'RPOP', key
         end
 
         def empty?
-          redis.call('EXISTS', key) == 0
+          redis.call!('EXISTS', key) == 0
         end
 
         def size

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