asynchronic 3.0.3 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cc53216188aca01f66806e933e68d3edacda3dabca5e93b3da3eae1a41bbae5
-  data.tar.gz: ad209146fc5b92f5d0d38c5d0ce27b72b6c6f7308831f9facb08a9bc7a538904
+  metadata.gz: 47872aa8b0fdee31f769749a1485e7be5ca2d5f9b7de51863c223547cad4849b
+  data.tar.gz: d7f0984211e6bfc46d1960a3b53aef3d3f244a619005504d7ba5e6c27612dbdd
 SHA512:
-  metadata.gz: 3e826e042a938689168e9ca085d4fd5f28250ed350ebdb658c871415b36df88088e290712c72558256c1535b247ead901fbae3818e692895f6e4d8052ab5f560
-  data.tar.gz: 2a1d517fb7cd29556d790e6680928e9294e79329b23a3e7ebab6e948ebc6a087d713cc2c3ca12908ca25f4798585198d35a88351c3f0723ad47d8e4b4416bb2d
+  metadata.gz: 1893074c7181e0eea27a276e781fdfc1680c909986ccbc80645aeafbd08ef44e3d23cfc82a3480bf1f453987aa75f0667aafd9b5c1f10ddfed5ec28067f2684b
+  data.tar.gz: f580a9b1660a3e1aa5fcac083b27cb73c169e2d68ac974114ddff6eb2cc24267deac81af780c4ccc2b84106021e6fbd554269674af9ec89bacd26f5f7c1714d0

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.rb

@@ -23,6 +23,8 @@ module Asynchronic
   attr_config :logger, Logger.new($stdout)
   attr_config :retry_timeout, 30
   attr_config :garbage_collector_timeout, 30
+  attr_config :redis_client, Redic
+  attr_config :redis_settings, 'redis://localhost:6379'
   attr_config :redis_data_store_sync_timeout, 0.01
   attr_config :keep_alive_timeout, 1
   attr_config :connection_name, "HOST=#{Socket.gethostname},PID=#{::Process.pid},UUID=#{SecureRandom.uuid}"
@@ -43,6 +45,12 @@ module Asynchronic
     @garbage_collector ||= GarbageCollector.new environment, garbage_collector_timeout
   end
 
+  def self.establish_redis_connection(options={})
+    redis_client = options.fetch(:redis_client, Asynchronic.redis_client)
+    redis_settings = options.fetch(:redis_settings, Asynchronic.redis_settings)
+    redis_client.new redis_settings
+  end
+
   def self.retry_execution(klass, message)
     begin
       result = yield

data/lib/asynchronic/data_store/in_memory.rb

@@ -4,7 +4,15 @@ 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 }
@@ -12,43 +20,37 @@ module Asynchronic
       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)
+        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/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]
@@ -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 }