asynchronic 1.6.3 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d090602f5e7db3b74e67c5057d7aec4761c2007e
-  data.tar.gz: b2e6ce2ff2d236510a71d91d7d5e0042179e4a64
+SHA256:
+  metadata.gz: 17e77f96cb1792507a8d82d9745bbf766c484cf4308bf41e268f33b28fb7671c
+  data.tar.gz: 33e566a52873e57adb7f79db2cfc179a269bf990ac57d9c0db3ebe698800c42d
 SHA512:
-  metadata.gz: dd1f22974965986b3ce74f2187edf7ad7911bee32562871a7591cea31a93fa22187beaa8b3e1fcf416a09560585460c51557669cc07c067eed6007d31d7959ed
-  data.tar.gz: 1a8db5dddd1501792e2bc00cfe57be14b0ef0c8f6e44d8c29a77c03bb0ce0f80d0cda483f87b84703f474a245e3bed611909e2496e0fc44e444cebca6b1bab82
+  metadata.gz: fac5b943ac35aa8d40ea3ec3bf73f3a827ecc6e040814c958a5a17f5d44a3bed544aa8956db5e7679b32cb9f2ccde5a859f20e3e0f150e85fe5d52fec6936dee
+  data.tar.gz: 70750e88c0c4a3ac3647c1d98bccd9e70447c92c226a11829175153c2bcf401e77ee07aff82b702cf8aee8db4c6961b0bf7e467304060592a176be0c29d3755c

data/.travis.yml

@@ -1,16 +1,15 @@
 language: ruby
 
 rvm:
-  - 1.9.3
   - 2.0
   - 2.1
   - 2.2
-  - 2.3.0
-  - 2.4.0
-  - 2.5.0
-  - 2.6.0
-  - jruby-1.7.25
-  - jruby-9.1.7.0
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7
+  - jruby-9.2.9.0
   - ruby-head
   - jruby-head
 
@@ -20,9 +19,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

@@ -4,7 +4,6 @@
 [![Build Status](https://travis-ci.org/gabynaiman/asynchronic.svg?branch=master)](https://travis-ci.org/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

@@ -18,25 +18,19 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'redis', '~> 3.0'
-  spec.add_dependency 'ost', '~> 0.1'
+  spec.add_dependency 'ost', '~> 1.0'
+  spec.add_dependency 'broadcaster', '~> 1.0'
   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'
   spec.add_development_dependency 'coveralls', '~> 0.8'
   spec.add_development_dependency 'pry-nav', '~> 0.2'
-
-  if RUBY_VERSION < '2'
-    spec.add_development_dependency 'term-ansicolor', '~> 1.3.0'
-    spec.add_development_dependency 'tins', '~> 1.6.0'
-    spec.add_development_dependency 'json', '~> 1.8'
-  end
 end

data/lib/asynchronic.rb

@@ -1,11 +1,14 @@
 require 'forwardable'
 require 'securerandom'
-require 'redis'
 require 'ost'
+require 'redic'
+require 'broadcaster'
 require 'class_config'
 require 'transparent_proxy'
 require 'logger'
 require 'multi_require'
+require 'timeout'
+require 'socket'
 
 MultiRequire.require_relative_pattern 'asynchronic/**/*.rb'
 
@@ -16,13 +19,16 @@ 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_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}"
 
   def self.environment
-    Environment.new queue_engine, data_store
+    Environment.new queue_engine, data_store, notifier
   end
 
   def self.[](pid)

data/lib/asynchronic/data_store/lazy_value.rb

@@ -18,7 +18,7 @@ module Asynchronic
       end
 
       def data_store
-        @data_store_class.connect *@data_store_connection_args
+        @data_store_class.connect(*@data_store_connection_args)
       end
 
       def to_value

data/lib/asynchronic/data_store/redis.rb

@@ -8,11 +8,11 @@ module Asynchronic
 
       def initialize(scope, *args)
         @scope = Key[scope]
-        @connection = ::Redis.new(*args)
+        @redis = Redic.new(*args)
       end
 
       def [](key)
-        value = @connection.get @scope[key]
+        value = @redis.call! 'GET', @scope[key]
         value ? Marshal.load(value) : nil
       rescue => ex
         Asynchronic.logger.warn('Asynchronic') { ex.message }
@@ -20,33 +20,33 @@ module Asynchronic
       end
 
       def []=(key, value)
-        @connection.set @scope[key], Marshal.dump(value)
+        @redis.call! 'SET', @scope[key], Marshal.dump(value)
       end
 
       def delete(key)
-        @connection.del @scope[key]
+        @redis.call! 'DEL', @scope[key]
       end
 
       def delete_cascade(key)
-        @connection.del @scope[key]
-        @connection.keys(@scope[key]['*']).each { |k| @connection.del k }
+        @redis.call! 'DEL', @scope[key]
+        @redis.call!('KEYS', @scope[key]['*']).each { |k| @redis.call! 'DEL', k }
       end
 
       def keys
-        @connection.keys(@scope['*']).map { |k| Key[k].remove_first }
+        @redis.call!('KEYS', @scope['*']).map { |k| Key[k].remove_first }
       end
 
       def synchronize(key)
-        while @connection.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
-        @connection.del @scope[key][LOCKED]
+        @redis.call! 'DEL', @scope[key][LOCKED]
       end
 
       def connection_args
-        [@scope, @connection.client.options]
+        [@scope, @redis.url]
       end
 
       def self.connect(*args)

data/lib/asynchronic/environment.rb

@@ -1,12 +1,12 @@
 module Asynchronic
   class Environment
 
-    attr_reader :queue_engine
-    attr_reader :data_store
+    attr_reader :queue_engine, :data_store, :notifier
     
-    def initialize(queue_engine, data_store)
+    def initialize(queue_engine, data_store, notifier)
       @queue_engine = queue_engine
       @data_store = data_store
+      @notifier = notifier
     end
 
     def queue(name)

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

data/lib/asynchronic/notifier/broadcaster.rb

@@ -0,0 +1,30 @@
+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
+
+    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

@@ -11,9 +11,11 @@ module Asynchronic
       aborted:   :finalized_at
     }
 
-    ATTRIBUTE_NAMES = [:type, :name, :queue, :status, :dependencies, :data, :result, :error] | TIME_TRACKING_MAP.values.uniq
+    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
 
@@ -47,6 +49,14 @@ module Asynchronic
       abort! CANCELED_ERROR_MESSAGE
     end
 
+    def dead?
+      (running? && !connected?) || processes.any?(&:dead?)
+    end
+
+    def abort_if_dead
+      abort! DEAD_ERROR_MESSAGE if dead?
+    end
+
     def destroy
       data_store.delete_cascade
     end
@@ -75,7 +85,7 @@ module Asynchronic
 
     def processes
       data_store.scoped(:processes).keys.
-        select { |k| k.sections.count == 2 && k.match(/name$/) }.
+        select { |k| k.sections.count == 2 && k.match(/\|name$/) }.
         sort.map { |k| Process.new environment, id[:processes][k.remove_last] }
     end
 
@@ -88,13 +98,11 @@ 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
@@ -186,8 +194,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|
@@ -202,19 +214,22 @@ 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
 
     def run
+      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 }
@@ -249,5 +264,12 @@ module Asynchronic
       parent.queue if parent
     end
 
+    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
 end

data/lib/asynchronic/queue_engine/in_memory.rb

@@ -33,6 +33,11 @@ module Asynchronic
         true
       end
 
+      def active_connections
+        [Asynchronic.connection_name]
+      end
+
+
       class Queue
 
         extend Forwardable

data/lib/asynchronic/queue_engine/ost.rb

@@ -1,17 +1,14 @@
 module Asynchronic
   module QueueEngine
     class Ost
-      
-      attr_reader :default_queue
 
-      def initialize(options={})
-        ::Ost.connect options[:redis] if options.key?(:redis)
-        @default_queue = options[:default_queue]
-        @queues ||= Hash.new { |h,k| h[k] = Queue.new k }
-      end
+      attr_reader :redis, :default_queue
 
-      def default_queue
-        @default_queue ||= Asynchronic.default_queue
+      def initialize(options={})
+        @redis = Redic.new(*Array(options[:redis]))
+        @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)
@@ -19,12 +16,12 @@ module Asynchronic
       end
 
       def queues
-        (@queues.values.map(&:key) | redis.keys('ost:*')).map { |q| q.to_s[4..-1].to_sym }
+        (@queues.values.map(&:key) | redis.call!('KEYS', 'ost:*')).map { |q| q.to_s[4..-1].to_sym }
       end
 
       def clear
         @queues.clear
-        redis.keys('ost:*').each { |k| redis.del k }
+        redis.call!('KEYS', 'ost:*').each { |k| redis.call!('DEL', k) }
       end
 
       def listener
@@ -35,21 +32,38 @@ module Asynchronic
         true
       end
 
+      def active_connections
+        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
 
-      def redis
-        @redis ||= Redis.connect(::Ost.options)
+      def notify_keep_alive
+        Thread.new do
+          loop do
+            redis.call! 'CLIENT', 'SETNAME', Asynchronic.connection_name
+            sleep Asynchronic.keep_alive_timeout
+          end
+        end
       end
 
 
       class Queue < ::Ost::Queue
 
+        def initialize(name, redis)
+          super name
+          self.redis = redis
+        end
+
         def pop
-          key.rpop
+          redis.call! 'RPOP', key
         end
 
         def empty?
-          !redis.exists(key)
+          redis.call!('EXISTS', key) == 0
         end
 
         def size
@@ -68,7 +82,7 @@ module Asynchronic
         def listen(queue, &block)
           @current_queue = queue
           Asynchronic.retry_execution(self.class, 'listen') do
-            queue.each &block
+            queue.each(&block)
           end
         end
 

data/lib/asynchronic/queue_engine/synchronic.rb

@@ -29,6 +29,11 @@ module Asynchronic
         false
       end
 
+      def active_connections
+        [Asynchronic.connection_name]
+      end
+
+
       class Queue
 
         def initialize(engine)

data/lib/asynchronic/version.rb

@@ -1,3 +1,3 @@
 module Asynchronic
-  VERSION = '1.6.3'
-end
+  VERSION = '3.0.2'
+end

data/lib/asynchronic/worker.rb

@@ -23,7 +23,7 @@ class Asynchronic::Worker
   end
 
   def stop
-    Asynchronic.logger.info('Asynchronic') { "Stopping worker of #{@queue_name} (#{Process.pid})" }
+    Asynchronic.logger.info('Asynchronic') { "Stopping worker of #{queue_name} (#{Process.pid})" }
     listener.stop
   end
 

data/spec/data_store/data_store_examples.rb

@@ -22,19 +22,19 @@ module DataStoreExamples
   end
 
   it 'Delete cascade' do
-    data_store[Key[:key_1]] = 1
-    data_store[Key[:key_1][:key_1_1]] = 2
-    data_store[Key[:key_1][:key_1_2]] = 3
-    data_store[Key[:key_2]] = 4
-    data_store[Key[:key_2][:key_2_1]] = 5
-    data_store[Key[:key_2][:key_2_2]] = 6
+    data_store[Asynchronic::DataStore::Key[:key_1]] = 1
+    data_store[Asynchronic::DataStore::Key[:key_1][:key_1_1]] = 2
+    data_store[Asynchronic::DataStore::Key[:key_1][:key_1_2]] = 3
+    data_store[Asynchronic::DataStore::Key[:key_2]] = 4
+    data_store[Asynchronic::DataStore::Key[:key_2][:key_2_1]] = 5
+    data_store[Asynchronic::DataStore::Key[:key_2][:key_2_2]] = 6
 
-    data_store.delete_cascade Key[:key_1]
+    data_store.delete_cascade Asynchronic::DataStore::Key[:key_1]
 
     data_store.keys.sort.must_equal [
-      Key[:key_2], 
-      Key[:key_2][:key_2_1], 
-      Key[:key_2][:key_2_2]
+      Asynchronic::DataStore::Key[:key_2], 
+      Asynchronic::DataStore::Key[:key_2][:key_2_1], 
+      Asynchronic::DataStore::Key[:key_2][:key_2_2]
     ]
   end
 

data/spec/data_store/lazy_value_examples.rb

@@ -26,7 +26,6 @@ module LazyValueExamples
   it 'Transparent proxy' do
     value = lazy_value :key
     data_store[:key] =  1
-    value.must_be_instance_of Fixnum
     value.must_equal 1
   end
 

data/spec/expectations.rb

@@ -75,6 +75,10 @@ module MiniTest::Assertions
     process.finalized_at.must_be_instance_of Time
   end
 
+  def assert_have_connection_name(process)
+    process.connection_name.must_equal Asynchronic.connection_name
+  end
+
 end
 
 Asynchronic::QueueEngine::InMemory::Queue.infect_an_assertion :assert_enqueued, :must_enqueued
@@ -85,4 +89,5 @@ Asynchronic::Process.infect_an_assertion :assert_be_pending, :must_be_pending, :
 Asynchronic::Process.infect_an_assertion :assert_be_queued, :must_be_queued, :unary
 Asynchronic::Process.infect_an_assertion :assert_be_waiting, :must_be_waiting, :unary
 Asynchronic::Process.infect_an_assertion :assert_be_completed, :must_be_completed, :unary
-Asynchronic::Process.infect_an_assertion :assert_be_aborted, :must_be_aborted, :unary
+Asynchronic::Process.infect_an_assertion :assert_be_aborted, :must_be_aborted, :unary
+Asynchronic::Process.infect_an_assertion :assert_have_connection_name, :must_have_connection_name, :unary

data/spec/facade_spec.rb

@@ -64,4 +64,16 @@ describe Asynchronic, 'Facade' do
     Asynchronic.garbage_collector.must_be_instance_of Asynchronic::GarbageCollector
   end
 
+  it 'Redis data store sync timeout' do
+    Asynchronic.redis_data_store_sync_timeout.must_equal 0.01
+  end
+
+  it 'Keep alive timeout' do
+    Asynchronic.keep_alive_timeout.must_equal 1
+  end
+
+  it 'Connection name' do
+    Asynchronic.connection_name.must_match /^HOST=#{Socket.gethostname},PID=#{::Process.pid}/
+  end
+
 end

data/spec/jobs.rb

@@ -200,7 +200,7 @@ end
 class WithRetriesJob < Asynchronic::Job
   def call
     @counter = 0
-    retry_when [RuntimeError] do
+    retry_when [RuntimeError], 0.1 do
       @counter += 1
       raise 'Counter < 3' if @counter < 3
       @counter
@@ -326,7 +326,7 @@ class NestedJobWithErrorInChildJob < Asynchronic::Job
 end
 
 
-class AbortQueuedAfertErrorJob < Asynchronic::Job
+class AbortQueuedAfterErrorJob < Asynchronic::Job
   def call
     async Child_1
     async Child_2

data/spec/minitest_helper.rb

@@ -3,8 +3,10 @@ require 'asynchronic'
 require 'minitest/autorun'
 require 'minitest/colorin'
 require 'minitest/great_expectations'
+require 'minitest/stub_any_instance'
 require 'jobs'
 require 'expectations'
+require 'timeout'
 require 'pry-nav'
 
 class Module

data/spec/process/life_cycle_examples.rb

@@ -1,26 +1,68 @@
 module LifeCycleExamples
   
-  let(:env) { Asynchronic::Environment.new queue_engine, data_store }
+  let(:env) { Asynchronic::Environment.new queue_engine, data_store, notifier }
 
   let(:queue) { env.default_queue }
 
   after do
     data_store.clear
     queue_engine.clear
+    notifier.unsubscribe_all
   end
 
   def create(type, params={})
-    env.create_process type, params
+    env.create_process(type, params).tap do |process|
+      process.must_be_initialized
+    end
   end
 
   def execute(queue)
-    env.load_process(queue.pop).execute
+    process = env.load_process(queue.pop)
+
+    events = []
+    status_changed_id = notifier.subscribe(process.id, :status_changed) { |status| events << status }
+
+    is_finalized = false
+    finalized_id = notifier.subscribe(process.id, :finalized) { is_finalized = true }
+
+    process.execute
+
+    process.must_have_connection_name
+    process.wont_be :dead?
+    
+    process.send(:connected?).must_be_true
+
+    env.queue_engine.stub(:active_connections, ->() { raise 'Forced error' }) do
+      process.send(:connected?).must_be_true
+    end
+
+    with_retries do
+      events.last.must_equal process.status
+      process.finalized?.must_equal is_finalized
+    end
+
+    notifier.unsubscribe status_changed_id
+    notifier.unsubscribe finalized_id
+
+    status = process.status
+    process.abort_if_dead
+    process.status.must_equal status
+  end
+
+  def with_retries(&block)
+    Timeout.timeout(3) do
+      begin
+        block.call
+      rescue Minitest::Assertion
+        sleep 0.001
+        retry
+      end
+    end
   end
 
   it 'Basic' do
     process = create BasicJob, input: 1
 
-    process.must_be_initialized
     process.must_have_params input: 1
     queue.must_be_empty
 
@@ -39,7 +81,6 @@ module LifeCycleExamples
   it 'Sequential' do
     process = create SequentialJob, input: 50
 
-    process.must_be_initialized
     process.must_have_params input: 50
     queue.must_be_empty
 
@@ -77,7 +118,6 @@ module LifeCycleExamples
   it 'Graph' do
     process = create GraphJob, input: 100
 
-    process.must_be_initialized
     process.must_have_params input: 100
     queue.must_be_empty
 
@@ -133,7 +173,6 @@ module LifeCycleExamples
   it 'Parallel' do
     process = create ParallelJob, input: 10, times: 3
 
-    process.must_be_initialized
     process.must_have_params input: 10, times: 3
     queue.must_be_empty
 
@@ -167,7 +206,6 @@ module LifeCycleExamples
   it 'Nested' do
     process = create NestedJob, input: 4
 
-    process.must_be_initialized
     process.must_have_params input: 4
     queue.must_be_empty
 
@@ -207,7 +245,6 @@ module LifeCycleExamples
   it 'Alias' do
     process = create AliasJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -261,7 +298,6 @@ module LifeCycleExamples
   it 'Custom queue' do
     process = create CustomQueueJob, input: 'hello'
 
-    process.must_be_initialized
     process.must_have_params input: 'hello'
 
     env.queue(:queue_1).must_be_empty
@@ -302,7 +338,6 @@ module LifeCycleExamples
   it 'Exception' do
     process = create ExceptionJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -320,7 +355,6 @@ module LifeCycleExamples
   it 'Inner exception' do
     process = create InnerExceptionJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -348,7 +382,6 @@ module LifeCycleExamples
   it 'Forward reference' do
     process = create ForwardReferenceJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -391,7 +424,6 @@ module LifeCycleExamples
   it 'Job with retries' do
     process = create WithRetriesJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -486,80 +518,81 @@ module LifeCycleExamples
     process.real_error.must_equal "Error in parent"
   end
 
-  it 'Abort queued afert error' do
-    process = create AbortQueuedAfertErrorJob
+  it 'Abort queued After error' do
+    process = create AbortQueuedAfterErrorJob
 
     process.enqueue 
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :waiting,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :queued
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :waiting,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :queued,
+                                   'AbortQueuedAfterErrorJob::Child_2' => :queued,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :queued,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :queued
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :waiting,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :waiting,
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :waiting,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :waiting,
                                    'Child_1_1'                         => :queued,
                                    'Child_1_2'                         => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :queued
+                                   'AbortQueuedAfterErrorJob::Child_2' => :queued,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :queued,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :queued
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :waiting,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :waiting,
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :waiting,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :waiting,
                                    'Child_1_1'                         => :queued,
                                    'Child_1_2'                         => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :completed,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :queued
+                                   'AbortQueuedAfterErrorJob::Child_2' => :completed,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :queued,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :queued
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :waiting,
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :waiting,
                                    'Child_1_1'                         => :queued,
                                    'Child_1_2'                         => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :completed,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :queued
+                                   'AbortQueuedAfterErrorJob::Child_2' => :completed,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :queued
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :waiting,
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :waiting,
                                    'Child_1_1'                         => :queued,
                                    'Child_1_2'                         => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :completed,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :aborted
+                                   'AbortQueuedAfterErrorJob::Child_2' => :completed,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :aborted
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :aborted,
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :aborted,
                                    'Child_1_1'                         => :aborted,
                                    'Child_1_2'                         => :queued,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :completed,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :aborted
+                                   'AbortQueuedAfterErrorJob::Child_2' => :completed,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :aborted
 
     execute queue
 
-    process.full_status.must_equal 'AbortQueuedAfertErrorJob'          => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_1' => :aborted,
+    process.full_status.must_equal 'AbortQueuedAfterErrorJob'          => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_1' => :aborted,
                                    'Child_1_1'                         => :aborted,
                                    'Child_1_2'                         => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_2' => :completed,
-                                   'AbortQueuedAfertErrorJob::Child_3' => :aborted,
-                                   'AbortQueuedAfertErrorJob::Child_4' => :aborted
+                                   'AbortQueuedAfterErrorJob::Child_2' => :completed,
+                                   'AbortQueuedAfterErrorJob::Child_3' => :aborted,
+                                   'AbortQueuedAfterErrorJob::Child_4' => :aborted
 
     process.real_error.must_equal 'Forced error'
+    process.processes[0].processes[1].error.message.must_equal Asynchronic::Process::AUTOMATIC_ABORTED_ERROR_MESSAGE
   end
 
   it 'Manual abort' do
@@ -604,7 +637,7 @@ module LifeCycleExamples
     pid_1 = process_1.id
     pid_2 = process_2.id
 
-    data_store.keys.select { |k| k.start_with? pid_1 }.count.must_equal 37
+    data_store.keys.select { |k| k.start_with? pid_1 }.count.must_equal 38
     data_store.keys.select { |k| k.start_with? pid_2 }.count.must_equal 7
 
     process_1.destroy
@@ -622,42 +655,49 @@ module LifeCycleExamples
     process_2.enqueue
     execute queue
 
+    process_3 = create BasicJob
+
     pid_1 = process_1.id
     pid_2 = process_2.id
+    pid_3 = process_3.id
 
     process_1.must_be_completed
     process_2.must_be_waiting
+    process_3.must_be_pending
 
-    data_store.keys.select { |k| k.start_with? pid_1 }.count.must_equal 49
-    data_store.keys.select { |k| k.start_with? pid_2 }.count.must_equal 37
+    data_store.keys.select { |k| k.start_with? pid_1 }.count.must_equal 53
+    data_store.keys.select { |k| k.start_with? pid_2 }.count.must_equal 38
+    data_store.keys.select { |k| k.start_with? pid_3 }.count.must_equal 7
 
     gc = Asynchronic::GarbageCollector.new env, 0.001
     
-    gc.add_condition('Completed', &:completed?)
+    gc.add_condition('Finalized', &:finalized?)
     gc.add_condition('Waiting', &:waiting?)
     gc.add_condition('Exception') { raise 'Invalid condition' }
 
-    gc.conditions_names.must_equal ['Completed', 'Waiting', 'Exception']
+    gc.conditions_names.must_equal ['Finalized', 'Waiting', 'Exception']
 
     gc.remove_condition 'Waiting'
     
-    gc.conditions_names.must_equal ['Completed', 'Exception']
+    gc.conditions_names.must_equal ['Finalized', 'Exception']
 
     Thread.new do
       sleep 0.01
       gc.stop
     end
 
-    gc.start
+    Asynchronic::Process.stub_any_instance(:dead?, -> { id == pid_3 }) do
+      gc.start
+    end
 
     data_store.keys.select { |k| k.start_with? pid_1 }.count.must_equal 0
-    data_store.keys.select { |k| k.start_with? pid_2 }.count.must_equal 37
+    data_store.keys.select { |k| k.start_with? pid_2 }.count.must_equal 38
+    data_store.keys.select { |k| k.start_with? pid_3 }.count.must_equal 0
   end
 
   it 'Before finalize hook when completed' do
     process = create BeforeFinalizeCompletedJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -675,7 +715,6 @@ module LifeCycleExamples
   it 'Before finalize hook when aborted' do
     process = create BeforeFinalizeAbortedJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -693,7 +732,6 @@ module LifeCycleExamples
   it 'Before finalize raises exception and aborts' do
     process = create BeforeFinalizeRaisesExceptionJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -711,7 +749,6 @@ module LifeCycleExamples
   it 'Before finalize raises exception on aborted job' do
     process = create BeforeFinalizeExceptionOnAbortedJob
 
-    process.must_be_initialized
     queue.must_be_empty
 
     process.enqueue
@@ -726,5 +763,4 @@ module LifeCycleExamples
     queue.must_be_empty
   end
 
-
 end

data/spec/process/life_cycle_in_memory_spec.rb

@@ -5,6 +5,7 @@ describe Asynchronic::Process, 'Life cycle - InMemory' do
 
   let(:queue_engine) { Asynchronic::QueueEngine::InMemory.new }
   let(:data_store) { Asynchronic::DataStore::InMemory.new }
+  let(:notifier) { Asynchronic::Notifier::InMemory.new }
 
   include LifeCycleExamples
 

data/spec/process/life_cycle_redis_spec.rb

@@ -5,6 +5,7 @@ describe Asynchronic::Process, 'Life cycle - Redis' do
 
   let(:queue_engine) { Asynchronic::QueueEngine::Ost.new }
   let(:data_store) { Asynchronic::DataStore::Redis.new :asynchronic_test }
+  let(:notifier) { Asynchronic::Notifier::Broadcaster.new }
 
   include LifeCycleExamples
 

data/spec/queue_engine/ost_spec.rb

@@ -11,5 +11,9 @@ describe Asynchronic::QueueEngine::Ost do
   end
   
   include QueueEngineExamples
+
+  it 'Engine and queues use same redis connection' do
+    engine.redis.must_equal queue.redis
+  end
   
 end

data/spec/queue_engine/queue_engine_examples.rb

@@ -31,17 +31,23 @@ module QueueEngineExamples
   end
 
   it 'Listener' do
-    queue.push 'msg_1'
-    queue.push 'msg_2'
+    Timeout.timeout(5) do
+      queue.push 'msg_1'
+      queue.push 'msg_2'
 
-    messages = []
+      messages = []
 
-    listener.listen(queue) do |msg|
-      messages << msg
-      listener.stop if queue.empty?
+      listener.listen(queue) do |msg|
+        messages << msg
+        listener.stop if queue.empty?
+      end
+
+      messages.must_equal %w(msg_1 msg_2)
     end
+  end
 
-    messages.must_equal %w(msg_1 msg_2)
+  it 'Active connections' do
+    engine.active_connections.must_equal [Asynchronic.connection_name]
   end
 
 end

data/spec/queue_engine/synchronic_spec.rb

@@ -34,5 +34,9 @@ describe Asynchronic::QueueEngine::Synchronic do
     process.must_be_completed
     process.result.must_equal '10%' => 20, '20%' => 40
   end
-  
+
+  it 'Active connections' do
+    Asynchronic.queue_engine.active_connections.must_equal [Asynchronic.connection_name]
+  end
+
 end

data/spec/worker/in_memory_spec.rb

@@ -5,6 +5,7 @@ describe Asynchronic::Worker, 'InMemory' do
 
   let(:queue_engine) { Asynchronic::QueueEngine::InMemory.new }
   let(:data_store) { Asynchronic::DataStore::InMemory.new }
+  let(:notifier) { Asynchronic::Notifier::InMemory.new }
 
   include WorkerExamples
   

data/spec/worker/redis_spec.rb

@@ -5,6 +5,7 @@ describe Asynchronic::Worker, 'Redis' do
 
   let(:queue_engine) { Asynchronic::QueueEngine::Ost.new }
   let(:data_store) { Asynchronic::DataStore::Redis.new :asynchronic_test}
+  let(:notifier) { Asynchronic::Notifier::Broadcaster.new }
 
   after do
     data_store.clear

data/spec/worker/worker_examples.rb

@@ -1,6 +1,6 @@
 module WorkerExamples
 
-  let(:env) { Asynchronic::Environment.new queue_engine, data_store }
+  let(:env) { Asynchronic::Environment.new queue_engine, data_store, notifier }
   let(:queue_name) { :test_worker }
   let(:queue) { env.queue queue_name }
 

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: asynchronic
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 3.0.2
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-05 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: redis
+  name: ost
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: ost
+  name: broadcaster
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: class_config
   requirement: !ruby/object:Gem::Requirement
@@ -80,34 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +128,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-stub_any_instance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest-colorin
   requirement: !ruby/object:Gem::Requirement
@@ -243,6 +243,8 @@ files:
 - lib/asynchronic/error.rb
 - lib/asynchronic/garbage_collector.rb
 - lib/asynchronic/job.rb
+- lib/asynchronic/notifier/broadcaster.rb
+- lib/asynchronic/notifier/in_memory.rb
 - lib/asynchronic/process.rb
 - lib/asynchronic/queue_engine/in_memory.rb
 - lib/asynchronic/queue_engine/ost.rb
@@ -289,8 +291,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: DSL for asynchronic pipeline using queues over Redis