asynchronic 3.0.3 → 4.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cc53216188aca01f66806e933e68d3edacda3dabca5e93b3da3eae1a41bbae5
-  data.tar.gz: ad209146fc5b92f5d0d38c5d0ce27b72b6c6f7308831f9facb08a9bc7a538904
+  metadata.gz: b6b02a7e0922a83bdb5cc7602ab49fe6e89dac37d82f6666c97dc0014a94c1f6
+  data.tar.gz: c2c237b5ea9ca4b72335a0d02face23ac7ab49b1d42af69c816c31a2298ea890
 SHA512:
-  metadata.gz: 3e826e042a938689168e9ca085d4fd5f28250ed350ebdb658c871415b36df88088e290712c72558256c1535b247ead901fbae3818e692895f6e4d8052ab5f560
-  data.tar.gz: 2a1d517fb7cd29556d790e6680928e9294e79329b23a3e7ebab6e948ebc6a087d713cc2c3ca12908ca25f4798585198d35a88351c3f0723ad47d8e4b4416bb2d
+  metadata.gz: 56e6d3c61dd259657d8738160e4b82978b4e1898089a023b7b675fcb1680b4c01e67dae5bb1cc09e22da98b062c1f1c737263f37c209007dc796c65895613425
+  data.tar.gz: dc6a6cec5e3c628d2e15255aba71d078a0bbe1c11ad34d77023663c3de4d78089b1e41316dcfd95aab4ddad3e7547c2b400ddb3a70259a71b2be0c7771c6dfde

data/.travis.yml

@@ -9,6 +9,7 @@ rvm:
   - 2.5
   - 2.6
   - 2.7
+  - 3.0
   - jruby-9.2.9.0
   - ruby-head
   - jruby-head

data/README.md

@@ -1,7 +1,7 @@
 # Asynchronic
 
 [![Gem Version](https://badge.fury.io/rb/asynchronic.svg)](https://rubygems.org/gems/asynchronic)
-[![Build Status](https://travis-ci.org/gabynaiman/asynchronic.svg?branch=master)](https://travis-ci.org/gabynaiman/asynchronic)
+[![Build Status](https://travis-ci.com/gabynaiman/asynchronic.svg?branch=master)](https://travis-ci.com/gabynaiman/asynchronic)
 [![Coverage Status](https://coveralls.io/repos/gabynaiman/asynchronic/badge.svg?branch=master)](https://coveralls.io/r/gabynaiman/asynchronic?branch=master)
 [![Code Climate](https://codeclimate.com/github/gabynaiman/asynchronic.svg)](https://codeclimate.com/github/gabynaiman/asynchronic)
 

data/lib/asynchronic/data_store/in_memory.rb

@@ -4,51 +4,56 @@ module Asynchronic
 
       include Helper
 
-      def initialize(hash={})
+      def self.connect(object_id)
+        connections[object_id]
+      end
+
+      def self.connections
+        @connections ||= {}
+      end
+
+      def initialize
         @hash = {}
         @mutex = Mutex.new
-        @keys_mutex = Hash.new { |h,k| h[k] = Mutex.new }
+        @keys_mutex = {}
         self.class.connections[object_id] = self
       end
 
       def [](key)
-        Marshal.load(@hash[key.to_s]) if @hash.key? key.to_s
+        Marshal.load(hash[key.to_s]) if hash.key? key.to_s
       end
 
       def []=(key, value)
-        @mutex.synchronize { @hash[key.to_s] = Marshal.dump(value) }
+        mutex.synchronize { hash[key.to_s] = Marshal.dump(value) }
       end
 
       def delete(key)
-        @hash.delete key.to_s
+        hash.delete key.to_s
       end
 
       def delete_cascade(key)
-        keys = self.keys.select { |k| k.sections.first == key }
-        keys.each { |k| delete k }
+        keys.select { |k| k.sections.first == key }
+            .each { |k| delete k }
       end
 
       def keys
-        @hash.keys.map { |k| Key[k] }
+        hash.keys.map { |k| Key[k] }
       end
 
       def synchronize(key, &block)
-        @keys_mutex[key].synchronize(&block)
+        mutex.synchronize do
+          keys_mutex[key] ||= Mutex.new
+        end
+        keys_mutex[key].synchronize(&block)
       end
 
       def connection_args
         [object_id]
       end
 
-      def self.connect(object_id)
-        connections[object_id]
-      end
-
       private
 
-      def self.connections
-        @connections ||= {}
-      end
+      attr_reader :hash, :mutex, :keys_mutex
 
     end
   end

data/lib/asynchronic/data_store/key.rb

@@ -1,19 +1,19 @@
 module Asynchronic
   module DataStore
     class Key < String
-    
+
       SEPARATOR = '|'
 
       def self.[](key)
         new key
       end
-      
+
       def initialize(key)
         super key.to_s
       end
 
       def [](key)
-        self.class.new [self,key].join(SEPARATOR)
+        self.class.new [self, key].join(SEPARATOR)
       end
 
       def sections

data/lib/asynchronic/data_store/lazy_value.rb

@@ -14,11 +14,11 @@ module Asynchronic
       end
 
       def inspect
-        "#<#{proxy_class} @data_store_class=#{@data_store_class} @data_store_connection_args=#{@data_store_connection_args} @key=#{@key}>"
+        "#<#{proxy_class} @data_store_class=#{data_store_class} @data_store_connection_args=#{data_store_connection_args} @key=#{key}>"
       end
 
       def data_store
-        @data_store_class.connect(*@data_store_connection_args)
+        data_store_class.connect(*data_store_connection_args)
       end
 
       def to_value
@@ -27,8 +27,10 @@ module Asynchronic
 
       private
 
+      attr_reader :data_store_class, :data_store_connection_args, :key
+
       def __getobj__
-        @value ||= data_store[@key]
+        @value ||= data_store[key]
       end
 
     end

data/lib/asynchronic/data_store/redis.rb

@@ -6,13 +6,17 @@ module Asynchronic
 
       include Helper
 
-      def initialize(scope, *args)
+      def self.connect(*args)
+        new(*args)
+      end
+
+      def initialize(scope, options={})
         @scope = Key[scope]
-        @redis = Redic.new(*args)
+        @options = options
       end
 
       def [](key)
-        value = @redis.call! 'GET', @scope[key]
+        value = redis.call! 'GET', scope[key]
         value ? Marshal.load(value) : nil
       rescue => ex
         Asynchronic.logger.warn('Asynchronic') { ex.message }
@@ -20,39 +24,43 @@ module Asynchronic
       end
 
       def []=(key, value)
-        @redis.call! 'SET', @scope[key], Marshal.dump(value)
+        redis.call! 'SET', scope[key], Marshal.dump(value)
       end
 
       def delete(key)
-        @redis.call! 'DEL', @scope[key]
+        redis.call! 'DEL', scope[key]
       end
 
       def delete_cascade(key)
-        @redis.call! 'DEL', @scope[key]
-        @redis.call!('KEYS', @scope[key]['*']).each { |k| @redis.call! 'DEL', k }
+        redis.call! 'DEL', scope[key]
+        redis.call!('KEYS', scope[key]['*']).each { |k| redis.call! 'DEL', k }
       end
 
       def keys
-        @redis.call!('KEYS', @scope['*']).map { |k| Key[k].remove_first }
+        redis.call!('KEYS', scope['*']).map { |k| Key[k].remove_first }
       end
 
       def synchronize(key)
-        while @redis.call!('GETSET', @scope[key][LOCKED], LOCKED) == LOCKED
+        while redis.call!('GETSET', scope[key][LOCKED], LOCKED) == LOCKED
           sleep Asynchronic.redis_data_store_sync_timeout
         end
         yield
       ensure
-        @redis.call! 'DEL', @scope[key][LOCKED]
+        redis.call! 'DEL', scope[key][LOCKED]
       end
 
       def connection_args
-        [@scope, @redis.url]
+        [scope, options]
       end
 
-      def self.connect(*args)
-        new(*args)
+      private
+
+      attr_reader :scope, :options
+
+      def redis
+        @redis ||= Asynchronic.establish_redis_connection options
       end
-      
+
     end
   end
 end

data/lib/asynchronic/data_store/scoped_store.rb

@@ -4,34 +4,38 @@ module Asynchronic
 
       include Helper
 
-      attr_reader :data_store
-      attr_reader :scope
-      
+      attr_reader :data_store, :scope
+
+      def self.connect(options)
+        data_store = options[:data_store_class].connect(*options[:data_store_connection_args])
+        new data_store, options[:scope]
+      end
+
       def initialize(data_store, scope)
         @data_store = data_store
         @scope = Key[scope]
       end
 
       def [](key)
-        @data_store[@scope[key]]
+        data_store[scope[key]]
       end
 
       def []=(key, value)
-        @data_store[@scope[key]] = value
+        data_store[scope[key]] = value
       end
 
       def delete(key)
-        @data_store.delete @scope[key]
+        data_store.delete scope[key]
       end
 
       def delete_cascade
-        @data_store.delete_cascade @scope
+        data_store.delete_cascade scope
       end
 
       def keys
-        @data_store.keys.
-          select { |k| k.start_with? @scope[''] }.
-          map { |k| Key[k].remove_first @scope.sections.count }
+        data_store.keys
+                  .select { |k| k.start_with? scope[''] }
+                  .map { |k| Key[k].remove_first scope.sections.count }
       end
 
       def synchronize(key, &block)
@@ -41,20 +45,15 @@ module Asynchronic
       def connection_args
         [
           {
-            data_store_class: @data_store.class,
-            data_store_connection_args: @data_store.connection_args,
-            scope: @scope
+            data_store_class: data_store.class,
+            data_store_connection_args: data_store.connection_args,
+            scope: scope
           }
         ]
       end
 
-      def self.connect(*args)
-        data_store = args[0][:data_store_class].connect *args[0][:data_store_connection_args]
-        new data_store, args[0][:scope]
-      end
-
       def to_s
-        "#<#{self.class} @data_store=#{@data_store} @scope=#{@scope}>"
+        "#<#{self.class} @data_store=#{data_store} @scope=#{scope}>"
       end
 
     end

data/lib/asynchronic/environment.rb

@@ -2,7 +2,7 @@ module Asynchronic
   class Environment
 
     attr_reader :queue_engine, :data_store, :notifier
-    
+
     def initialize(queue_engine, data_store, notifier)
       @queue_engine = queue_engine
       @data_store = data_store
@@ -14,7 +14,7 @@ module Asynchronic
     end
 
     def default_queue
-      queue(queue_engine.default_queue)
+      queue queue_engine.default_queue
     end
 
     def enqueue(msg, queue=nil)
@@ -28,7 +28,7 @@ module Asynchronic
     def load_process(id)
       Process.new self, id
     end
-    
+
     def processes
       Process.all self
     end

data/lib/asynchronic/error.rb

@@ -1,9 +1,8 @@
 module Asynchronic
   class Error
 
-    attr_reader :message
-    attr_reader :backtrace
-    
+    attr_reader :message, :backtrace
+
     def initialize(source)
       @message = source.respond_to?(:message) ? source.message : source.to_s
       @backtrace = source.respond_to?(:backtrace) ? source.backtrace : []

data/lib/asynchronic/garbage_collector.rb

@@ -25,7 +25,8 @@ module Asynchronic
           begin
             processes.select(&condition).each(&:destroy)
           rescue => ex
-            Asynchronic.logger.error('Asynchronic') { "#{ex.class}: #{ex.message}" }
+            error_message = "#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}"
+            Asynchronic.logger.error('Asynchronic') { error_message }
           end
         end
 

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

@@ -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

@@ -19,6 +19,30 @@ module Asynchronic
 
     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]
@@ -50,7 +74,7 @@ module Asynchronic
     end
 
     def dead?
-      (running? && !connected?) || processes.any?(&:dead?)
+      (running? && !connected?) || (!finalized? && processes.any?(&:dead?))
     end
 
     def abort_if_dead
@@ -84,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
@@ -107,11 +133,11 @@ module Asynchronic
 
     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
 
@@ -135,7 +161,7 @@ module Asynchronic
         wakeup_children
       end
       Asynchronic.logger.info('Asynchronic') { "Wakeup finalized #{type} (#{id})" }
-      
+
       parent.wakeup if parent && finalized?
     end
 
@@ -151,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
@@ -194,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
@@ -229,7 +232,7 @@ module Asynchronic
         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