asynchronic 2.0.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1e125dac6480974894d48275d0015bb85410a9f4
-  data.tar.gz: 07b4801fd659a5c0735ccac5dc24c5340363afa8
+SHA256:
+  metadata.gz: 47872aa8b0fdee31f769749a1485e7be5ca2d5f9b7de51863c223547cad4849b
+  data.tar.gz: d7f0984211e6bfc46d1960a3b53aef3d3f244a619005504d7ba5e6c27612dbdd
 SHA512:
-  metadata.gz: d68006d635184823ac8bcdc4669690b4778b295b4eb98c5b8b4375c0284be30db220ee87bf3f6f7fc932365adb26a3196116b6549ef3432fa2391ec1395f7363
-  data.tar.gz: 630f880110f71041ab2bc18f5ad5258298b8f3d18560315569aa18ed8459986af20c3768cc3dc77992c82db3d2dce496125ad4931902cddd6ad11d4aaa8fe09e
+  metadata.gz: 1893074c7181e0eea27a276e781fdfc1680c909986ccbc80645aeafbd08ef44e3d23cfc82a3480bf1f453987aa75f0667aafd9b5c1f10ddfed5ec28067f2684b
+  data.tar.gz: f580a9b1660a3e1aa5fcac083b27cb73c169e2d68ac974114ddff6eb2cc24267deac81af780c4ccc2b84106021e6fbd554269674af9ec89bacd26f5f7c1714d0

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,14 +19,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'ost', '~> 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'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
   spec.add_development_dependency 'simplecov', '~> 0.12'

data/lib/asynchronic.rb

@@ -2,6 +2,7 @@ require 'forwardable'
 require 'securerandom'
 require 'ost'
 require 'redic'
+require 'broadcaster'
 require 'class_config'
 require 'transparent_proxy'
 require 'logger'
@@ -18,15 +19,18 @@ module Asynchronic
   attr_config :default_queue, :asynchronic
   attr_config :queue_engine, QueueEngine::InMemory.new
   attr_config :data_store, DataStore::InMemory.new
+  attr_config :notifier, Notifier::InMemory.new
   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, 0.1
-  attr_config :connection_name, "HOST=#{Socket.gethostname},PID=#{::Process.pid}"
+  attr_config :keep_alive_timeout, 1
+  attr_config :connection_name, "HOST=#{Socket.gethostname},PID=#{::Process.pid},UUID=#{SecureRandom.uuid}"
 
   def self.environment
-    Environment.new queue_engine, data_store
+    Environment.new queue_engine, data_store, notifier
   end
 
   def self.[](pid)
@@ -41,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

@@ -1,12 +1,12 @@
 module Asynchronic
   class Environment
 
-    attr_reader :queue_engine
-    attr_reader :data_store
-    
-    def initialize(queue_engine, data_store)
+    attr_reader :queue_engine, :data_store, :notifier
+
+    def initialize(queue_engine, data_store, notifier)
       @queue_engine = queue_engine
       @data_store = data_store
+      @notifier = notifier
     end
 
     def queue(name)
@@ -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

@@ -18,6 +18,8 @@ module Asynchronic
       while @running
         processes = environment.processes
 
+        processes.each(&:abort_if_dead)
+
         conditions.each do |name, condition|
           Asynchronic.logger.info('Asynchronic') { "Running GC - #{name}" }
           begin