asynchronic 3.0.1 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0e0f25f70fa41da06affe41aa2fb639b7bfd542a
-  data.tar.gz: 0a59f33dece383cd47df04ee457221101bbed618
+SHA256:
+  metadata.gz: 1927d93fad4703789a566429a5e31767e332ca9f17cbe94db92f899587398a38
+  data.tar.gz: 64a6f3c8fc8d9248166ba6b1fc0dcc4f9d51a6229f3a2f3d4b99b645dd92059f
 SHA512:
-  metadata.gz: 80d20d5b4ca50a04ed124b03d7b76000847a433877b45bb7bd2dc77e22f0984ec6f4215af76bd5a881a5bd550b67725a3a1d856698f96d878f9f55725e181c67
-  data.tar.gz: 51c7ed3e8686731277c31fbdea1bcb2bfc62c10959fbbcab7cf46a4d0cf6dc7f7ff2c6063eb5eea4809aeed773a150593787b1fdef6ca1d7afef8cf2c4531ed1
+  metadata.gz: '0207949f35f7e91d8b5506d469e85f023071a5bbfbc17631fbbf4f5da76e22f2224d4bc08ecf347fe0b34f06e08d063c3db1e1b7d0c81a6ff164c4d9e1ba21a7'
+  data.tar.gz: 17f48dc8a1bb5aed62d28aa5a22d1c6f6271fa5b39a0032fce098148c22185a88803e741760b8aa8b35a3b765d5675136b9808b62e996bd0138d8cac5d866b2a

data/.travis.yml

@@ -4,12 +4,13 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
-  - 2.3.0
-  - 2.4.0
-  - 2.5.0
-  - 2.6.0
-  - jruby-9.1.17.0
-  - jruby-9.2.7.0
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - 3.0
+  - jruby-9.2.9.0
   - ruby-head
   - jruby-head
 
@@ -19,9 +20,5 @@ matrix:
     - rvm: ruby-head
     - rvm: jruby-head
 
-before_install:
-  - rvm all-gemsets do gem uninstall bundler -ax || true
-  - gem install bundler -v "< 2"
-
 services:
   - redis-server

data/README.md

@@ -1,10 +1,9 @@
 # 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)
-[![Dependency Status](https://gemnasium.com/gabynaiman/asynchronic.svg)](https://gemnasium.com/gabynaiman/asynchronic)
 
 DSL for asynchronic pipeline using queues over Redis
 

data/asynchronic.gemspec

@@ -19,13 +19,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'ost', '~> 1.0'
-  spec.add_dependency 'broadcaster', '~> 1.0'
+  spec.add_dependency 'broadcaster', '~> 1.0', '>= 1.0.2'
   spec.add_dependency 'class_config', '~> 0.0'
   spec.add_dependency 'transparent_proxy', '~> 0.0'
   spec.add_dependency 'multi_require', '~> 1.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.12'
-  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-great_expectations', '~> 0.0'
   spec.add_development_dependency 'minitest-stub_any_instance', '~> 1.0'

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