enkidu 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cc70fb3863d61c5a67e5b6089de27b48a1cc1be
-  data.tar.gz: 7b35191f85577c0fa859ab15912b60eb9979f09f
+  metadata.gz: 1703c3004e749c132e16c7dca1eceec5fb30f875
+  data.tar.gz: ea4c9081b396051029e64e5429a1a4dbb57b9306
 SHA512:
-  metadata.gz: 1cfb5b0739aa65b78667a53f020cc4539ef78cf01f6eaae0f25c9898d164a3a37b6ef0d90cee24305057ff4aab6b3a8fa6b5615ecf23aa6ada11decb4b879b3b
-  data.tar.gz: 69b02f4e3fb66053fd80b4ec47612d65f79c0009399b1a764db096ac8e9256ebb0626eb01a7dbc472bdbc9f50f8da34b237d98f05c2a9d8810bd7a111b531e55
+  metadata.gz: 2829b255bdca0dfe35fc315992493929c29c7d6a8c3c6307d4dc011de8dfef8ba99dd96d1fbea4902ec2f326852582abafd761c0fa96fbdbbf57723b3db1a3f4
+  data.tar.gz: 738636e61003210c68cb3cd43eb317ce8938561ab1bdef0f5b9e768144766f453fe0e7eea9045d651300afb45b1b9f5a7301fdf6cda2f8e3a08c5217338305c5

data/lib/enkidu/dispatcher.rb

@@ -26,46 +26,113 @@ module Enkidu
   #   d.run #Blocks
   class Dispatcher
 
-    STOP = Object.new
-    k=self;STOP.define_singleton_method(:inspect){ "<#{k.name}::STOP>" }
+    class StateError < StandardError; end
 
-    def initialize
+    RUNNING = :running
+    STOPPED = :stopped
+
+    class STOP
+      attr_reader :callback, :cleanup
+      alias cleanup? cleanup
+      def initialize(callback:nil, cleanup:true)
+        @callback = callback
+        @cleanup = cleanup
+      end
+      def callable?
+        !!callback
+      end
+      def call(*a)
+        @callback && @callback.call(*a)
+      end
+    end
+
+    attr_reader :state
+
+
+    def initialize(&b)
       @lock = Mutex.new
       @queue = []
       @handlers = []
+      @plugins = []
+      @handler_serial = -1
       @r, @w = IO.pipe
-      yield self if block_given?
+      @state = STOPPED
+      if b
+        if b.arity.nonzero?
+          yield self
+        else
+          instance_eval(&b)
+        end
+      end
+    end
+
+
+    def running?
+      state == RUNNING
+    end
+
+    def stopped?
+      state == STOPPED
     end
 
 
     # Run the loop. This will block the current thread until the loop is stopped.
     def run
+      raise StateError, "Dispatcher is already running" if running?
+      @state = RUNNING
+      value = nil
+      plugins.each do |plugin|
+        plugin.run if plugin.respond_to?(:run)
+      end
       loop do
         IO.select [@r]
-        if vals = sync{ queue.shift }
-          sync{ @r.read(1) }
+        if vals = sync{ @r.read(1); queue.shift }
           callable, args = *vals
-          if callable == STOP
+          if callable.is_a?(STOP)
+            if callable.cleanup?
+              plugins.each do |plugin|
+                plugin.stop if plugin.respond_to?(:stop)
+              end
+            end
+            if callable.callable?
+              value = callable.call(*args)
+            end
+            @state = STOPPED
             break
           else
-            callable.call(*args)
+            value = callable.call(*args)
           end
         end
       end
+
+      value
+    end
+
+    # Runs the loop in the same manner as `run`, but will only execute any already
+    # scheduled (as in scheduled before the call to `run_once`) callables and then stop.
+    #
+    #   d = Dispatcher.new
+    #   d.schedule{ puts "hello" }
+    #   d.run_once #Runs the 1 scheduled callable above and returns
+    def run_once(*args, **kwargs, &b)
+      schedule_stop(*args, callable: b, **kwargs)
+      run
     end
 
 
     # Schedule a callable to be run. This will push the callable to the back of
     # the queue, so anything scheduled before it will run first.
+    # TODO: Allow kwargs to be passed to callable
     #
     #   schedule{ puts "I have been called" }
     #   callable = ->(arg){ p arg }
     #   schedule('an argument', callable: callable)
-    def schedule(*args, callable: nil, &b)
+    def schedule(*args, callable: nil, **kwargs, &b)
+      args << kwargs
       callable = callable(callable, b)
       sync do
         queue.push [callable, args]
-        @w.write '.'
+        @w.write '.' #TODO Figure out what to do when this blocks (pipe is full); lock will not be released
       end
     end
     alias push schedule
@@ -74,7 +141,8 @@ module Enkidu
     #
     #   schedule{ puts "Hey, that's not nice :(" }
     #   unshift{ puts "Cutting in line" }
-    def unshift(*args, callable: nil, &b)
+    def unshift(*args, callable: nil, **kwargs, &b)
+      args << kwargs
       callable = callable(callable, b)
       sync do
         queue.unshift [callable, args]
@@ -82,18 +150,83 @@ module Enkidu
       end
     end
 
+    # Schedule multiple callables at once
+    #
+    # Takes an array of [callable, args, position] arrays. args defaults to [], position to :back
+    # All callables are guaranteed to be added to the scheduler atomically; that is, neither of
+    # the passed callables nor any already scheduled callables will run until they have all been
+    # scheduled.
+    #
+    # The array bundles are processed in the order they appear in the array, so each callable
+    # will be added either at the back (default) or the front in that order.
+    #
+    #   #               Note: the :back here is unnecessary:
+    #   schedule_multiple([[->(msg){ puts msg }, ['hello'], :back], [->{ puts "I will run first" }, [], :front], [->{ puts "I will run last" }, []]])
+    def schedule_multiple(bundles)
+      sync do
+        bundles.each do |callable, args=[], position=:back|
+          if position == :front
+            queue.unshift [callable, args]
+          else
+            queue.push [callable, args]
+          end
+          @w.write '.'
+        end
+      end
+    end
+
+
+    def schedule_stop(*args, callable: nil, **kwargs, &b)
+      schedule(*args, callable: STOP.new(callback: callable || b), **kwargs)
+    end
+
+    def unshift_stop(*args, callable: nil, cleanup: true, **kwargs, &b)
+      unshift(*args, callable: STOP.new(callback: callable || b, cleanup: cleanup), **kwargs)
+    end
+
 
     # Stop the dispatcher. This schedules a special STOP signal that will stop the
     # dispatcher when encountered. This means that all other items that were scheduled
     # before it will run first.
-    def stop
-      schedule(callable: STOP)
+    #
+    # This action is idempotent; it returns true if the dispatcher is currently running
+    # and will be stopped, false if it's already stopped.
+    #
+    # A callable can be provided either in the form of the callable: kwarg or a block,
+    # which will be called after the dispatcher has stopped (also if dispatcher is already stopped).
+    #
+    # All attached plugins will have their `stop` method called before shutdown.
+    def stop(*args, callable: nil, **kwargs, &b)
+      callable ||= b
+      if stopped?
+        callable && callable.call(*args, **kwargs)
+        false
+      else
+        schedule_stop(*args, callable: callable, **kwargs)
+        true
+      end
     end
 
-    # Stop the dispatcher immediately by scheduling it at the front of the queue. This
-    # means that any other already scheduled items will be ignored.
-    def stop!
-      unshift(callable: STOP)
+    # Stop the dispatcher immediately by scheduling the stop action at the front of the
+    # queue. This means that any other already scheduled items will be ignored.
+    #
+    # This action is idempotent; it returns true if the dispatcher is currently running
+    # and will be stopped, false if it's already stopped.
+    #
+    # A callable can be provided either in the form of the `callable` option or a block,
+    # which will be called after the dispatcher has stopped (also if dispatcher is already stopped).
+    #
+    # If the `cleanup` option is true, all attached plugins will have their `stop` method
+    # called before shutdown.
+    def stop!(*args, callable: nil, cleanup: false, **kwargs, &b)
+      callable ||= b
+      if stopped?
+        callable && callable.call(*args, **kwargs)
+        false
+      else
+        unshift_stop(*args, callable: callable, cleanup: cleanup, **kwargs)
+        true
+      end
     end
 
 
@@ -107,14 +240,19 @@ module Enkidu
     #   signal ['foo', 'bar', 'baz'], arg1, arg2 #Same as above
     def signal(type, *args)
       type = type.join('.') if Array === type
+      scheduled_handlers = []
+      #puts "SIGNAL: #{type}, #{handlers.size} handlers"
       0.upto(handlers.size - 1).each do |index|
         if vals = sync{ handlers[index] }
-          regex, handler = *vals
+          id, regex, handler = *vals
+          #puts "HANDLER: #{regex.inspect} =~ #{type} => #{!!(regex =~ type)} -> #{handler.inspect}"
           if regex =~ type
-            schedule(*args, callable: handler)
+            schedule(type, *args, callable: handler)
+            scheduled_handlers << id
           end
         end#if vals
       end#each
+      scheduled_handlers
     end
 
 
@@ -135,24 +273,72 @@ module Enkidu
     #
     #   * An Array: The elements of the array are joined with a '.', and the
     #               resulting string is used as above.
+    #
+    # Returns a unique ID which can be used to deregister the handler from the
+    # dispatcher with `remove_handler`.
     def add_handler(type, callable=nil, &b)
       callable = callable(callable, b)
       regex = regex_for(type)
       sync do
-        handlers << [regex, callable]
+        id = @handler_serial+=1
+        handlers << [id, regex, callable]
+        id
       end
     end
+    alias subscribe add_handler
     alias on add_handler
 
 
-    def add(source, name=nil)
-      source = source.new(self) if Class === source
+    def remove_handler(id)
+      index = handlers.index{|i,*| i == id }
+      sync{ handlers.delete_at(index) }
+    end
+    alias unsubscribe remove_handler
+
+
+    # Add a plugin to this dispatcher. Plugins are objects that attach themselves
+    # to the dispatcher during its lifecycle and listen for or send events. Examples
+    # of plugins are SignalSource, LogSource and LogSink, that use the dispatcher to
+    # listen for and dispatch interrupt signals and log messages.
+    #
+    # `plugin` can be any object. It can also be a class, in which case its `new` method
+    # will be called with the dispatcher as the argument. It is not required to add objects
+    # that interact with the scheduler using this method, but doing so has some advantages:
+    #
+    # * If a second argument is provided, an accessor to the object will be available
+    #   on the dispatcher with the name provided:
+    #
+    #     dispatcher.use(SignalSource, :signals)
+    #     dispatcher.signals.on_int{ puts "Got INT"; dispatcher.stop }
+    #
+    # * Any object registered in this way will have its `run` and `stop` methods called
+    #   when the dispatcher starts and stops to do initialization/cleanup. The `run`
+    #   method will also be called when a plugin is added if the dispatcher is already
+    #   running.
+    #
+    #     class PingPong
+    #       def initialize(d)
+    #         @dispatcher = d
+    #       end
+    #       def run
+    #         @handler_id = @dispatcher.on('ping'){ @dispatcher.signal('pong') }
+    #       end
+    #       def stop
+    #         @dispatcher.remove_handler(@handler_id)
+    #       end
+    #     end
+    #TODO rename -> `use`
+    def add(plugin, name=nil)
+      plugin = plugin.new(self) if plugin.is_a?(Class)
       sync do
+        plugins << plugin
         define_singleton_method name do
-          source
+          plugin
         end if name
       end
+      plugin.run if running? && plugin.respond_to?(:run)
     end
+    alias use add
 
 
     def self.run(*a, &b)
@@ -170,7 +356,7 @@ module Enkidu
     #   ['foo', '*', 'baz']   => /\Afoo\.[^\.]+\.baz\Z/  #foo.*.baz
     #   ['foo', '#', 'baz']   => /\Afoo\..*?\.baz\Z/     #foo.#.baz
     #
-    # A string will be split('.') first, and a RegExp returned as-is.
+    # A string will be split('.') first, and a Regexp returned as-is.
     def regex_for(pattern)
       return pattern if Regexp === pattern
       pattern = pattern.split('.') if String === pattern
@@ -178,10 +364,19 @@ module Enkidu
       source = ''
       pattern.each_with_index do |part, index|
         if part == '*'
-          source << '\\.' unless index == 0
-          source << '[^\.]+'
+          if index == 0
+            source << '[^\.]+'
+          else
+            source << '\\.[^\.]+'
+          end
         elsif part == '#'
-          source << '.*?' # .*?  ?
+          if index == 0
+            source << '.*?'
+          elsif index == pattern.size-1
+            source << "\\Z|\\A#{source}\\..*"
+          else
+            source << '\\..*?'
+          end
         else
           source << '\\.' unless index == 0
           source << part
@@ -206,6 +401,10 @@ module Enkidu
       @queue
     end
 
+    def plugins
+      @plugins
+    end
+
     def callable(*cs)
       cs.each do |c|
         return c if c
@@ -213,6 +412,19 @@ module Enkidu
       raise ArgumentError, "No callable detected"
     end
 
+    # Called from inside the loop to execute a callable. This method is extracted only to
+    # avoid repetition; it's not to be used for other purposes.
+    def run_callable(callable, args)
+      if callable.is_a?(STOP)
+        @state = STOPPED
+        callable.call(*args)
+        true #Loop should be stopped
+      else
+        callable.call(*args)
+        false #Loop should continue
+      end
+    end
+
   end
 
 
@@ -220,18 +432,35 @@ module Enkidu
 
   class ThreadedDispatcher < Dispatcher
 
+    attr_reader :thread
+
+
     def run
+      running = false
+      unshift{ running = true }
       @thread = Thread.new do
+        Thread.current.abort_on_exception = true
         super
       end
-      @thread.abort_on_exception = true
+      sleep 0.01 until running #Block current thread until scheduler thread is up and running
       @thread
     end
 
-    def join
-      @thread.join
+
+    def join(*a)
+      @thread.join(*a)
     end
 
+    def value
+      @thread.value
+    end
+
+    def wait(*a)
+      stop
+      join(*a)
+    end
+
+
   end#class ThreadedDispatcher
 
 

data/lib/enkidu/logging.rb

@@ -1,5 +1,7 @@
 require 'enkidu/dispatcher'
 require 'enkidu/tools'
+require 'securerandom'
+require 'time'
 
 module Enkidu
 
@@ -17,28 +19,34 @@ module Enkidu
     end
 
 
-    def log(atts)
-      atts = Enkidu.deep_merge(defaults, atts)
-      path = atts[:type] || atts['type'] || 'log'
-      dispatcher.signal(path, atts)
+    def log(*args)
+      signal attify(args)
     end
 
-    def info(atts)
-      log(Enkidu.deep_merge({tags: ['INFO']}, atts))
+    def info(*args)
+      atts = attify(args)
+      atts[:tags].unshift('INFO')
+      signal atts
     end
 
-    def error(atts)
-      log(Enkidu.deep_merge({tags: ['ERROR']}, atts))
+    def error(*args)
+      atts = attify(args)
+      atts[:tags].unshift('ERROR')
+      signal atts
     end
 
-    def exception(e)
-      atts = {tags: ['ERROR', 'EXCEPTION'], message: "#{e.class}: #{e.message}"}
-      atts[:exception] = {type: e.class.name, message: e.message, stacktrace: e.backtrace}
+    def exception(e, *args)
+      atts = attify(args)
+      atts[:tags].unshift('EXCEPTION')
+      atts[:tags].unshift('ERROR')
+
+      atts[:message] ||= "#{e.class}: #{e.message}"
+      atts[:data][:exception] = {type: e.class.name, message: e.message, stacktrace: e.backtrace}
       if e.respond_to?(:cause) && e.cause
-        atts[:exception][:cause] = {type: e.cause.class.name, message: e.cause.message, stacktrace: e.cause.backtrace}
+        atts[:data][:exception][:cause] = {type: e.cause.class.name, message: e.cause.message, stacktrace: e.cause.backtrace}
       end
 
-      log atts
+      signal atts
     end
 
     def tail(pattern='#', &b)
@@ -48,6 +56,29 @@ module Enkidu
 
   private
 
+    def signal(atts)
+      dispatcher.signal(atts[:type], atts)
+    end
+
+    def attify(args)
+      aa = if args[0].is_a?(String)
+        args[1] ? {message: args[0]}.merge(args[1]) : {message: args[0]}
+      else
+        args[0] ? args[0].dup : {}
+      end
+      if aa[:atts]
+        if aa[:attributes]
+          aa[:attributes].update(aa.delete(:atts))
+        else
+          aa[:attributes] = aa.delete(:atts)
+        end
+      end
+      Enkidu.deep_merge(
+        Enkidu.deep_merge(defaults, {id: SecureRandom.uuid, time: Time.now.utc, type: 'log', tags: [], attributes: {}, data: {}}),
+        aa
+      )
+    end
+
     def dispatcher
       @dispatcher
     end
@@ -60,24 +91,152 @@ module Enkidu
 
   class LogSink
 
+
+
+
+
+    class DefaultFormatter
+
+
+      def initialize
+      end
+
+
+      def tags(msg)
+        return '[] ' unless msg[:tags]
+        "[#{msg[:tags].map{|t| escape_tag(t) }.join(', ')}] "
+      end
+
+
+      def attributes(msg)
+        return '{} ' unless msg[:attributes]
+        "{#{msg[:attributes].map{|k,v| "#{escape_attr k}=#{escape_attr v}" }.join(', ')}} "
+      end
+
+
+      def message(msg)
+        "#{msg[:message]}" +
+        if e = msg[:data][:exception]
+          "\n  #{e[:type]}: #{e[:message]}\n#{e[:stacktrace].map{|l| "    #{l}" }.join("\n")}"
+        else
+          ''
+        end
+      end
+
+
+      def timestamp(msg)
+        msg[:time].getutc.iso8601(3)
+      end
+
+
+      def call(msg)
+        id = msg[:id].split('-')[0]
+        "<#{id} #{timestamp msg}> " + tags(msg) + attributes(msg) + message(msg) + " </#{id}>"
+      end
+
+
+      def escape_tag(str)
+        "#{str}".gsub(/([\[\],])/, '\\\\\\1')
+      end
+
+      def escape_attr(str)
+        "#{str}".gsub(/([\{\}=,])/, '\\\\\\1')
+      end
+
+    end#class DefaultFormatter
+
+
+
+
+    class HumanFormatter
+
+      def tags(m)
+        return '' unless m[:tags] && m[:tags].any?
+        tags_separator(m) + m[:tags].map{|t| tag(t) }.join(', ')
+      end
+
+      def tag(t)
+        if ['ERROR', 'EXCEPTION'].include?(t)
+          c [1, 91], t
+        else
+          c 1, t
+        end
+      end
+
+      def tags_separator(m)
+        " #{c 96, '❯❯'} "
+      end
+
+
+      def atts(m)
+        return '' unless m[:attributes] && m[:attributes].any?
+        atts_separator(m) + c(37, m[:attributes].map{|k,v| "#{k}: #{v}" }.join(', '))
+      end
+
+      def atts_separator(m)
+        " #{c 96, '❯❯'} "
+      end
+
+
+      def timestamp(m)
+        m[:time].getlocal.strftime('%H:%M:%S')
+      end
+
+
+      def message(m)
+        " ❯❯ #{m[:message]}" +
+        if e = m[:data][:exception]
+          "\n  #{c 1, e[:type]}: #{e[:message]}\n#{e[:stacktrace].map{|l| "    #{l}" }.join("\n")}"
+        else
+          ''
+        end
+      end
+
+
+      def call(m)
+        timestamp(m) + tags(m) + atts(m) + message(m)
+      end
+
+
+      def color(n, s=nil)
+        c = Array(n).map{|nn| "\e[0;#{nn}m" }.join
+        c << "#{s}\e[0m" if s
+        c
+      end
+      alias c color
+
+
+      def stop
+        "\e[0m"
+      end
+      alias s stop
+
+
+    end#class HumanFormatter
+
+
+
+
+
     attr_reader :filter
 
-    def initialize(d, io:, filter: 'log.#', formatter: nil)
+    def initialize(d, io:, filter: 'log.#', formatter: nil, flush: false)
       @dispatcher = d
       @io = io
       @filter = filter
-      @formatter = formatter
-      run
+      @formatter = formatter.is_a?(Class) ? formatter.new : formatter
+      @flush = io.respond_to?(:flush) ? flush : false
     end
 
     def run
-      dispatcher.on filter do |msg|
+      dispatcher.on filter do |_,msg|
         log msg
       end
     end
 
     def log(msg)
       io.puts format(msg)
+      io.flush if flush?
     end
 
     def format(msg)
@@ -85,12 +244,12 @@ module Enkidu
     end
 
     def formatter
-      @formatter ||= -> msg do
-        (msg[:tags] ? msg[:tags].map{|t| "[#{t}]" }.join+' ' : '') +
-        (msg[:atts] ? msg[:atts].map{|k,v| "[#{k}=#{"#{v}"[0,10]}]" }.join+' ' : '') +
-        "#{msg[:message]}" +
-        (msg[:exception] ? "\n#{msg[:exception][:type]}: #{msg[:exception][:message]}\n#{msg[:exception][:stacktrace].map{|l| "  #{l}" }.join("\n")}" : '')
-      end
+      @formatter ||= DefaultFormatter.new
+    end
+
+
+    def flush?
+      @flush
     end
 
 

data/lib/enkidu/signals.rb

@@ -1,8 +1,138 @@
-require 'thread'
-
 module Enkidu
 
 
+  # SignalTrapper is a generic callback-based signal handling utility. It queues
+  # all signals onto a background thread and all callbacks are run, synchronously
+  # and serially, on this thread. This means signal handlers will be reentrant;
+  # any callbacks registered are guaranteed to finish before any other callback
+  # triggered by a signal starts running.
+  #
+  # Only one SignalTrapper should exist per process, as having multiple risks
+  # one overriding the other's signal handlers.
+  #
+  #   st = SignalTrapper.new
+  #   handler = -> s do
+  #     puts "Received #{s}, shutting down..."
+  #     app.stop #Do cleanup and shutdown
+  #     st.stop  #Tell ST to stop
+  #   end
+  #   st.register('INT', handler)
+  #   st.register('TERM', handler)
+  #   usr1 = st.register('USR1', ->(s){ puts app.stats })
+  #   st.register('USR2', ->(s){ st.deregister(usr1) })
+  #
+  #   st.join
+  class SignalTrapper
+
+
+    class Subscription
+      attr_reader :signal, :id
+      def initialize(s, i)
+        @signal, @id = s, i
+      end
+      def ==(other)
+        if other.is_a?(self.class)
+          id == other.id
+        else
+          id == other
+        end
+      end
+    end
+
+    SIGNALS = Signal.list
+
+
+    def initialize
+      @q = []
+      @r, @w = IO.pipe
+      @trapped_signals = []
+      @callbacks = Hash.new{|h,k| h[k] = [] }
+      @callback_serial = -1
+      @thread = Thread.new do
+        loop do
+          IO.select [@r]
+          sig = @q.shift
+          break if sig == :stop
+          @r.read 1
+          @callbacks[sig].each do |id, callable|
+            callable.call(sig)
+          end
+        end
+      end
+    end
+
+
+    # Register a callable for a specific signal. The callback will be scheduled
+    # on the handler thread when the signal is received.
+    #
+    # Returns an ID which can be used to `deregister` the callback
+    def register(sig, callable)
+      sig = self.class.normalize_signal(sig)
+      trap sig
+      id = Subscription.new(sig, @callback_serial += 1)
+      @callbacks[sig] << [id, callable]
+      id
+    end
+
+    # Deregister a callback using the ID returned by `register`
+    def deregister(id)
+      @callbacks[id.signal].delete_if{|i, _c| i == id }
+    end
+
+
+    # Tell signal handling thread to stop. It will execute any already scheduled
+    # handlers and then exit. No more handlers will be executed after that.
+    def stop
+      @q << :stop
+      @w.write '.'
+    end
+
+    # Join the callback execution thread. This will block until the SignalTrapper
+    # is told to `stop`.
+    def join(*a, &b)
+      @thread.join(*a, &b)
+    end
+
+    # `stop` and `join`
+    def wait(*a, &b)
+      stop
+      join(*a, &b)
+    end
+
+
+    # Normalize signal name
+    #
+    #   2      -> INT
+    #   SIGINT -> INT
+    #   INT    -> INT
+    #   123    -> ArgumentError
+    def self.normalize_signal(sig)
+      if sig.is_a?(Integer) || sig =~ /^\d+$/
+        SIGNALS.key(sig.to_i) || raise(ArgumentError, "Unrecognized signal #{sig}")
+      elsif sig =~ /^SIG(.+)$/
+        $1
+      else
+        sig
+      end
+    end
+
+
+  private
+
+    def trap(sig)
+      unless @trapped_signals.include?(sig)
+        Signal.trap sig do
+          @q << sig
+          @w.write '.'
+        end
+      end
+    end
+
+
+  end#class SignalTrapper
+
+
+
 
 
   # A SignalSource will trap signals and put handlers on a Dispatcher's queue instead
@@ -19,38 +149,106 @@ module Enkidu
   #   d.join
   class SignalSource
 
-    SIGNALS = Signal.list
 
 
-    def initialize(dispatcher)
+    class ShutdownProcedure
+
+      attr_reader :signals, :count
+
+      def initialize(signals, callable)
+        @signals = signals
+        @handlers = []
+        @count = 0
+        callable.call(self)
+      end
+
+      def handle(&b)
+        @handlers << b
+      end
+
+      def force(status=false, &b)
+        @force = {status: status, callback: b}
+      end
+
+      def call(signal)
+        @count += 1
+
+        if handler = @handlers.shift
+          handler.call(signal, count)
+        end#if handler
+
+        if @handlers.empty? && @force
+          signals.each do |signal|
+            Signal.trap signal do
+              begin
+                @force[:callback].call(signal) if @force[:callback]
+              rescue => e
+                warn "Exception while running force handler: #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+              ensure
+                exit @force[:status]
+              end
+            end#Signal.trap
+          end#signals.each
+        end#if @handlers.empty?
+      end
+
+    end
+
+
+
+    SIGNALS = SignalTrapper::SIGNALS
+
+    attr_reader :trapper
+
+
+    def self.trapper
+      @trappers ||= {}
+      @trappers[$$] ||= SignalTrapper.new
+    end
+
+
+    def initialize(dispatcher, trapper: self.class.trapper)
       @dispatcher = dispatcher
-      @q = Queue.new
-      run
+      @trapper = trapper
+      @subscriptions = []
     end
 
     def run
-      Thread.new do
-        loop do
-          sig = @q.pop
-          dispatcher.signal("signal.#{sig}", sig)
-        end
-      end
+    end
+
+    def stop
     end
 
     def on(*signals, callable:nil, &b)
-      signals = signals.map do |signal|
-        Integer === signal ? Signal.signame(signal) : signal
-      end
-      signals.each do |signal|
-        dispatcher.on("signal.#{signal}", callable || b)
+      subscriptions = signals.map do |signal|
+        dispatcher.on("signal.#{normalize signal}", callable || b)
       end
       register *signals
+      subscriptions
     end
     alias trap on
 
+    def off(*ids)
+      ids.each do |id|
+        dispatcher.unsubscribe(id)
+      end
+    end
+
+    def shutdown(*signals, callable:nil, &b)
+      sp = ShutdownProcedure.new(signals, callable || b)
+      on(*signals){|_,s| sp.call(s) }
+      sp
+    end
+
     def register(*signals)
       signals.each do |signal|
-        Signal.trap(signal){ @q.push signal } #TODO not reentrant
+        signal = normalize(signal)
+        unless @subscriptions.any?{|s| s.signal == signal }
+          @subscriptions << trapper.register(
+            signal,
+            ->(sig){ dispatcher.signal("signal.#{signal}", sig) }
+          )
+        end
       end
     end
 
@@ -67,6 +265,10 @@ module Enkidu
       @dispatcher
     end
 
+    def normalize(signal)
+      SignalTrapper.normalize_signal(signal)
+    end
+
 
   end#class SignalSource
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enkidu
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Tore Darell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-06 00:00:00.000000000 Z
+date: 2017-01-21 00:00:00.000000000 Z
 dependencies: []
 description: Enkidu is a process sidekick
 email: toredarell@gmail.com
@@ -40,7 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Enkidu process sidekick