concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/lib/concurrent/null_thread_pool.rb

@@ -5,8 +5,11 @@ module Concurrent
   class NullThreadPool
     behavior(:global_thread_pool)
 
-    def self.post(*args, &block)
-      Thread.new(*args, &block).abort_on_exception = false
+    def self.post(*args)
+      Thread.new(*args) do
+        Thread.current.abort_on_exception = false
+        yield(*args)
+      end
       return true
     end
 

data/lib/concurrent/obligation.rb

@@ -1,7 +1,8 @@
 require 'thread'
 require 'timeout'
+require 'functional'
 
-require 'functional/behavior'
+require 'concurrent/event'
 
 behavior_info(:future,
               state: 0,
@@ -42,26 +43,15 @@ module Concurrent
     def pending?() return(@state == :pending); end
 
     def value(timeout = nil)
-      if timeout == 0 || ! pending?
-        return @value
-      elsif timeout.nil?
-        return mutex.synchronize { v = @value }
-      else
-        begin
-          return Timeout::timeout(timeout.to_f) {
-            mutex.synchronize { v = @value }
-          }
-        rescue Timeout::Error => ex
-          return nil
-        end
-      end
+      event.wait(timeout) unless timeout == 0 || @state != :pending
+      return @value
     end
     alias_method :deref, :value
 
     protected
 
-    def mutex
-      @mutex ||= Mutex.new
+    def event
+      @event ||= Event.new
     end
   end
 end

data/lib/concurrent/promise.rb

@@ -2,7 +2,6 @@ require 'thread'
 
 require 'concurrent/global_thread_pool'
 require 'concurrent/obligation'
-require 'concurrent/utilities'
 
 module Concurrent
 
@@ -80,7 +79,7 @@ module Concurrent
     # @param block [Proc] the block to call if the rescue is matched
     #
     # @return [self] so that additional chaining can occur
-    def rescue(clazz = Exception, &block)
+    def rescue(clazz = nil, &block)
       return self if fulfilled? || rescued? || ! block_given?
       @lock.synchronize do
         rescuer = Rescuer.new(clazz, block)
@@ -140,12 +139,12 @@ module Concurrent
     # @private
     def try_rescue(ex, *rescuers) # :nodoc:
       rescuers = @rescuers if rescuers.empty?
-      rescuer = rescuers.find{|r| ex.is_a?(r.clazz) }
+      rescuer = rescuers.find{|r| r.clazz.nil? || ex.is_a?(r.clazz) }
       if rescuer
         rescuer.block.call(ex)
         @rescued = true
       end
-    rescue Exception => e
+    rescue Exception => ex
       # supress
     end
 
@@ -157,12 +156,12 @@ module Concurrent
         loop do
           current = lock.synchronize{ chain[index] }
           unless current.rejected?
-            current.mutex.synchronize do
-              begin
-                result = current.on_fulfill(result)
-              rescue Exception => ex
-                current.on_reject(ex)
-              end
+            begin
+              result = current.on_fulfill(result)
+            rescue Exception => ex
+              current.on_reject(ex)
+            ensure
+              event.set
             end
           end
           index += 1

data/lib/concurrent/runnable.rb

@@ -0,0 +1,103 @@
+require 'thread'
+require 'functional'
+
+behavior_info(:runnable,
+              run: 0,
+              stop: 0,
+              running?: 0)
+
+module Concurrent
+
+  module Running
+
+    class Context
+      attr_reader :runner, :thread
+      def initialize(runner)
+        @runner = runner
+        @thread = Thread.new(runner) do |runner|
+          Thread.abort_on_exception = false
+          runner.run
+        end
+      end
+    end
+
+    def self.included(base)
+
+      def run!
+        return mutex.synchronize do
+          raise LifecycleError.new('already running') if @running
+          Context.new(self)
+        end
+      end
+
+      protected
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      public
+
+      class << base
+
+        def run!(*args, &block)
+          runner = self.new(*args, &block)
+          return Context.new(runner)
+        rescue => ex
+          return nil
+        end
+      end
+    end
+  end
+
+  module Runnable
+
+    behavior(:runnable)
+
+    LifecycleError = Class.new(StandardError)
+
+    def self.included(base)
+      base.send(:include, Running)
+    end
+
+    def run
+      mutex.synchronize do
+        raise LifecycleError.new('already running') if @running
+        raise LifecycleError.new('#on_task not implemented') unless self.respond_to?(:on_task, true)
+        on_run if respond_to?(:on_run, true)
+        @running = true
+      end
+
+      loop do
+        break unless @running
+        on_task
+        break unless @running
+        Thread.pass
+      end
+
+      after_run if respond_to?(:after_run, true)
+      return true
+    rescue LifecycleError => ex
+      @running = false
+      raise ex
+    rescue => ex
+      @running = false
+      return false
+    end
+
+    def stop
+      return true unless @running
+      mutex.synchronize do
+        @running = false
+        on_stop if respond_to?(:on_stop, true)
+      end
+      return true
+    rescue => ex
+      return false
+    end
+
+    def running?
+      return @running == true
+    end
+  end
+end

data/lib/concurrent/supervisor.rb

@@ -1,71 +1,134 @@
 require 'thread'
 require 'functional'
 
-behavior_info(:runnable,
-              run: 0,
-              stop: 0,
-              running?: 0)
+require 'concurrent/runnable'
 
 module Concurrent
 
   class Supervisor
 
+    behavior(:runnable)
+
     DEFAULT_MONITOR_INTERVAL = 1
+    RESTART_STRATEGIES = [:one_for_one, :one_for_all, :rest_for_one]
+    DEFAULT_MAX_RESTART = 5
+    DEFAULT_MAX_TIME = 60
 
-    behavior(:runnable)
+    CHILD_TYPES = [:worker, :supervisor]
+    CHILD_RESTART_OPTIONS = [:permanent, :transient, :temporary]
 
-    WorkerContext = Struct.new(:worker, :thread)
+    MaxRestartFrequencyError = Class.new(StandardError)
+
+    WorkerContext = Struct.new(:worker, :type, :restart) do
+      attr_accessor :thread
+      attr_accessor :terminated
+      def alive?() return thread && thread.alive?; end
+      def needs_restart?
+        return false if thread && thread.alive?
+        return false if terminated == true
+        case self.restart
+        when :permanent
+          return true
+        when :transient
+          return thread.nil? || thread.status.nil?
+        else #when :temporary
+          return false
+        end
+      end
+    end
+
+    WorkerCounts = Struct.new(:specs, :supervisors, :workers) do
+      attr_accessor :status
+      def add(context)
+        self.specs += 1
+        self.supervisors += 1 if context.type == :supervisor
+        self.workers += 1 if context.type == :worker
+      end
+      def active() sleeping + running + aborting end;
+      def sleeping() @status.reduce(0){|x, s| x += (s == 'sleep' ? 1 : 0) } end;
+      def running() @status.reduce(0){|x, s| x += (s == 'run' ? 1 : 0) } end;
+      def aborting() @status.reduce(0){|x, s| x += (s == 'aborting' ? 1 : 0) } end;
+      def stopped() @status.reduce(0){|x, s| x += (s == false ? 1 : 0) } end;
+      def abend() @status.reduce(0){|x, s| x += (s.nil? ? 1 : 0) } end;
+    end
 
     attr_reader :monitor_interval
+    attr_reader :restart_strategy
+    attr_reader :max_restart
+    attr_reader :max_time
+
+    alias_method :strategy, :restart_strategy
+    alias_method :max_r, :max_restart
+    alias_method :max_t, :max_time
 
     def initialize(opts = {})
+      @restart_strategy = opts[:restart_strategy] || opts[:strategy] || :one_for_one
+      @monitor_interval = (opts[:monitor_interval] || DEFAULT_MONITOR_INTERVAL).to_f
+      @max_restart = (opts[:max_restart] || opts[:max_r] || DEFAULT_MAX_RESTART).to_i
+      @max_time = (opts[:max_time] || opts[:max_t] || DEFAULT_MAX_TIME).to_i
+
+      raise ArgumentError.new(":#{@restart_strategy} is not a valid restart strategy") unless RESTART_STRATEGIES.include?(@restart_strategy)
+      raise ArgumentError.new(':monitor_interval must be greater than zero') unless @monitor_interval > 0.0
+      raise ArgumentError.new(':max_restart must be greater than zero') unless @max_restart > 0
+      raise ArgumentError.new(':max_time must be greater than zero') unless @max_time > 0
+
+      @running = false
       @mutex = Mutex.new
       @workers = []
-      @running = false
       @monitor = nil
-      @monitor_interval = opts[:monitor] || opts[:monitor_interval] || DEFAULT_MONITOR_INTERVAL
+
+      @count = WorkerCounts.new(0, 0, 0)
+      @restart_times = []
+
       add_worker(opts[:worker]) unless opts[:worker].nil?
+      add_workers(opts[:workers]) unless opts[:workers].nil?
     end
 
     def run!
-      raise StandardError.new('already running') if running?
       @mutex.synchronize do
+        raise StandardError.new('already running') if @running
         @running = true
-        @monitor = Thread.new{ monitor }
-        @monitor.abort_on_exception = false
+        @monitor = Thread.new do
+          Thread.current.abort_on_exception = false
+          monitor
+        end
       end
       Thread.pass
     end
 
     def run
-      raise StandardError.new('already running') if running?
-      @running = true
+      @mutex.synchronize do
+        raise StandardError.new('already running') if @running
+        @running = true
+      end
       monitor
+      return true
     end
 
     def stop
-      return true unless running?
-      @running = false
+      return true unless @running
       @mutex.synchronize do
-        Thread.kill(@monitor) unless @monitor.nil?
-        @monitor = nil
-
-        until @workers.empty?
-          context = @workers.pop
-          begin
-            context.worker.stop
-            Thread.pass
-          rescue Exception => ex
-            # suppress
-          ensure
-            Thread.kill(context.thread) unless context.thread.nil?
+        @running = false
+        unless @monitor.nil?
+          @monitor.run if @monitor.status == 'sleep'
+          if @monitor.join(0.1).nil?
+            @monitor.kill
           end
+          @monitor = nil
+        end
+        @restart_times.clear
+
+        @workers.length.times do |i|
+          context = @workers[-1-i]
+          terminate_worker(context)
         end
+        prune_workers
       end
+      return true
     end
 
     def running?
-      return @running
+      return @running == true
     end
 
     def length
@@ -73,33 +136,197 @@ module Concurrent
     end
     alias_method :size, :length
 
-    def add_worker(worker)
-      if worker.nil? || running? || ! worker.behaves_as?(:runnable)
-        return false
-      else
-        @mutex.synchronize {
-          @workers << WorkerContext.new(worker)
-        }
-        return true
+    def current_restart_count
+      return @restart_times.length
+    end
+
+    def count
+      return @mutex.synchronize do
+        @count.status = @workers.collect{|w| w.thread ? w.thread.status : false }
+        @count.dup.freeze
+      end
+    end
+
+    def add_worker(worker, opts = {})
+      return nil if worker.nil? || ! worker.behaves_as?(:runnable)
+      return @mutex.synchronize {
+        restart = opts[:restart] || :permanent
+        type = opts[:type] || (worker.is_a?(Supervisor) ? :supervisor : nil) || :worker
+        raise ArgumentError.new(":#{restart} is not a valid restart option") unless CHILD_RESTART_OPTIONS.include?(restart)
+        raise ArgumentError.new(":#{type} is not a valid child type") unless CHILD_TYPES.include?(type)
+        context = WorkerContext.new(worker, type, restart)
+        @workers << context
+        @count.add(context)
+        worker.run if running?
+        context.object_id
+      }
+    end
+    alias_method :add_child, :add_worker
+
+    def add_workers(workers, opts = {})
+      return workers.collect do |worker|
+        add_worker(worker, opts)
+      end
+    end
+    alias_method :add_children, :add_workers
+
+    def remove_worker(worker_id)
+      return @mutex.synchronize do
+        index, context = find_worker(worker_id)
+        break(nil) if context.nil?
+        break(false) if context.alive?
+        @workers.delete_at(index)
+        context.worker
+      end
+    end
+    alias_method :remove_child, :remove_worker
+
+    def stop_worker(worker_id)
+      return true unless running?
+      return @mutex.synchronize do
+        index, context = find_worker(worker_id)
+        break(nil) if index.nil?
+        context.terminated = true
+        terminate_worker(context)
+        @workers.delete_at(index) if @workers[index].restart == :temporary
+        true
+      end
+    end
+    alias_method :stop_child, :stop_worker
+
+    def start_worker(worker_id)
+      return false unless running?
+      return @mutex.synchronize do
+        index, context = find_worker(worker_id)
+        break(nil) if context.nil?
+        context.terminated = false
+        run_worker(context) unless context.alive?
+        true
       end
     end
+    alias_method :start_child, :start_worker
+
+    def restart_worker(worker_id)
+      return false unless running?
+      return @mutex.synchronize do
+        index, context = find_worker(worker_id)
+        break(nil) if context.nil?
+        break(false) if context.restart == :temporary
+        context.terminated = false
+        terminate_worker(context)
+        run_worker(context)
+        true
+      end
+    end
+    alias_method :restart_child, :restart_worker
 
     private
 
     def monitor
+      @workers.each{|context| run_worker(context)}
       loop do
+        sleep(@monitor_interval)
+        break unless running?
         @mutex.synchronize do
-          @workers.each do |context|
-            unless context.thread && context.thread.alive?
-              context.thread = Thread.new{ context.worker.run }
-              context.thread.abort_on_exception = false
-            end
-          end
+          prune_workers
+          self.send(@restart_strategy)
         end
         break unless running?
-        sleep(@monitor_interval)
-        break unless running?
       end
+    rescue MaxRestartFrequencyError => ex
+      stop
+    end
+
+    def run_worker(context)
+      context.thread = Thread.new do
+        Thread.current.abort_on_exception = false
+        context.worker.run
+      end
+      return context
     end
+
+    def terminate_worker(context)
+      if context.alive?
+        context.worker.stop
+        Thread.pass
+      end
+    rescue Exception => ex
+      begin
+        Thread.kill(context.thread)
+      rescue
+        # suppress
+      end
+    ensure
+      context.thread = nil
+    end
+
+    def prune_workers
+      @workers.delete_if{|w| w.restart == :temporary && ! w.alive? }
+    end
+
+    def find_worker(worker_id)
+      index = @workers.find_index{|worker| worker.object_id == worker_id}
+      if index.nil?
+        return [nil, nil]
+      else
+        return [index, @workers[index]]
+      end
+    end
+
+    def exceeded_max_restart_frequency?
+      @restart_times.unshift(Time.now.to_i)
+      diff = delta(@restart_times.first, @restart_times.last)
+      if @restart_times.length >= @max_restart && diff <= @max_time
+        return true
+      elsif diff >= @max_time
+        @restart_times.pop
+      end
+      return false
+    end
+
+    #----------------------------------------------------------------
+    # restart strategies
+
+    def one_for_one
+      @workers.each do |context|
+        if context.needs_restart?
+          raise MaxRestartFrequencyError if exceeded_max_restart_frequency?
+          run_worker(context)
+        end
+      end
+    end
+
+    def one_for_all
+      restart = false
+
+      restart = @workers.each do |context|
+        if context.needs_restart?
+          raise MaxRestartFrequencyError if exceeded_max_restart_frequency?
+          break(true)
+        end
+      end
+
+      if restart
+        @workers.each do |context|
+          terminate_worker(context)
+        end
+        @workers.each{|context| run_worker(context)}
+      end
+    end
+
+    def rest_for_one
+      restart = false
+
+      @workers.each do |context|
+        if restart
+          terminate_worker(context)
+        elsif context.needs_restart?
+          raise MaxRestartFrequencyError if exceeded_max_restart_frequency?
+          restart = true
+        end
+      end
+
+      one_for_one if restart
     end
   end
+end