enkidu 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cc70fb3863d61c5a67e5b6089de27b48a1cc1be
+  data.tar.gz: 7b35191f85577c0fa859ab15912b60eb9979f09f
+SHA512:
+  metadata.gz: 1cfb5b0739aa65b78667a53f020cc4539ef78cf01f6eaae0f25c9898d164a3a37b6ef0d90cee24305057ff4aab6b3a8fa6b5615ecf23aa6ada11decb4b879b3b
+  data.tar.gz: 69b02f4e3fb66053fd80b4ec47612d65f79c0009399b1a764db096ac8e9256ebb0626eb01a7dbc472bdbc9f50f8da34b237d98f05c2a9d8810bd7a111b531e55

data/lib/enkidu/dispatcher.rb

@@ -0,0 +1,240 @@
+require 'securerandom'
+require 'thread'
+
+
+module Enkidu
+
+
+
+
+  # The Dispatcher maintains a queue of callable objects that are run in the order
+  # they get added. When there is nothing in the queue, it blocks the thread.
+  #
+  # Operations on the Dispatcher are thread-safe.
+  #
+  # If you do not want to block the current thread, check ThreadedDispatcher.
+  #
+  #   d = Dispatcher.new
+  #   d.schedule{ puts "hello from the scheduler" }
+  #   d.schedule{ puts "i will run after the first one" }
+  #   d.on('event'){|arg| puts arg } #Add a handler for 'event'
+  #   d.on(/[ea]v[ea]nt/){|*a| puts "handling 'event' or 'avant'" }
+  #
+  #   Thread.new{ sleep 5; d.stop } #Stop the dispatcher after 5 seconds
+  #
+  #   d.signal 'event', 'argument here' #Signalling doesn't actually run handlers, just schedules them
+  #   d.run #Blocks
+  class Dispatcher
+
+    STOP = Object.new
+    k=self;STOP.define_singleton_method(:inspect){ "<#{k.name}::STOP>" }
+
+    def initialize
+      @lock = Mutex.new
+      @queue = []
+      @handlers = []
+      @r, @w = IO.pipe
+      yield self if block_given?
+    end
+
+
+    # Run the loop. This will block the current thread until the loop is stopped.
+    def run
+      loop do
+        IO.select [@r]
+        if vals = sync{ queue.shift }
+          sync{ @r.read(1) }
+          callable, args = *vals
+          if callable == STOP
+            break
+          else
+            callable.call(*args)
+          end
+        end
+      end
+    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.
+    #
+    #   schedule{ puts "I have been called" }
+    #   callable = ->(arg){ p arg }
+    #   schedule('an argument', callable: callable)
+    def schedule(*args, callable: nil, &b)
+      callable = callable(callable, b)
+      sync do
+        queue.push [callable, args]
+        @w.write '.'
+      end
+    end
+    alias push schedule
+
+    # Schedule a callable to be run immediately by putting it at the front of the queue.
+    #
+    #   schedule{ puts "Hey, that's not nice :(" }
+    #   unshift{ puts "Cutting in line" }
+    def unshift(*args, callable: nil, &b)
+      callable = callable(callable, b)
+      sync do
+        queue.unshift [callable, args]
+        @w.write '.'
+      end
+    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)
+    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)
+    end
+
+
+    # Signal an event
+    #
+    # If a handler is found that matches the given type, it is scheduled to be executed
+    #
+    # `type` is =~ against each handler's regex, each handler that matches is scheduled
+    #
+    #   signal 'foo.bar.baz', arg1, arg2
+    #   signal ['foo', 'bar', 'baz'], arg1, arg2 #Same as above
+    def signal(type, *args)
+      type = type.join('.') if Array === type
+      0.upto(handlers.size - 1).each do |index|
+        if vals = sync{ handlers[index] }
+          regex, handler = *vals
+          if regex =~ type
+            schedule(*args, callable: handler)
+          end
+        end#if vals
+      end#each
+    end
+
+
+    # Add an event handler. The given callable will be scheduled when an event
+    # matching `type` is `signal`ed.
+    #
+    # The `type` is either:
+    #
+    #   * A Regexp: For each signalled event, `type` will be =~ against the
+    #               event, and the callable scheduled on a match.
+    #
+    #   * A String: The string will be converted to a Regexp that matches
+    #               using the same rules as AMQP-style subscriptions:
+    #
+    #                 * foo.bar.baz.quux
+    #                 * foo.*.baz.quux
+    #                 * foo.#.quux
+    #
+    #   * An Array: The elements of the array are joined with a '.', and the
+    #               resulting string is used as above.
+    def add_handler(type, callable=nil, &b)
+      callable = callable(callable, b)
+      regex = regex_for(type)
+      sync do
+        handlers << [regex, callable]
+      end
+    end
+    alias on add_handler
+
+
+    def add(source, name=nil)
+      source = source.new(self) if Class === source
+      sync do
+        define_singleton_method name do
+          source
+        end if name
+      end
+    end
+
+
+    def self.run(*a, &b)
+      d = new(*a, &b)
+      d.run
+      d
+    end
+
+
+  private
+
+    # Convert an AMQP-style pattern into a Regexp matching the same strings.
+    #
+    #   ['foo', 'bar', 'baz'] => /\Afoo\.bar\.baz\Z/     #foo.bar.baz
+    #   ['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.
+    def regex_for(pattern)
+      return pattern if Regexp === pattern
+      pattern = pattern.split('.') if String === pattern
+
+      source = ''
+      pattern.each_with_index do |part, index|
+        if part == '*'
+          source << '\\.' unless index == 0
+          source << '[^\.]+'
+        elsif part == '#'
+          source << '.*?' # .*?  ?
+        else
+          source << '\\.' unless index == 0
+          source << part
+        end
+      end
+
+      Regexp.new("\\A#{source}\\Z")
+    end
+
+    def synchronize
+      @lock.synchronize do
+        yield
+      end
+    end
+    alias sync synchronize
+
+    def handlers
+      @handlers
+    end
+
+    def queue
+      @queue
+    end
+
+    def callable(*cs)
+      cs.each do |c|
+        return c if c
+      end
+      raise ArgumentError, "No callable detected"
+    end
+
+  end
+
+
+
+
+  class ThreadedDispatcher < Dispatcher
+
+    def run
+      @thread = Thread.new do
+        super
+      end
+      @thread.abort_on_exception = true
+      @thread
+    end
+
+    def join
+      @thread.join
+    end
+
+  end#class ThreadedDispatcher
+
+
+
+
+end#module Enkidu

data/lib/enkidu/logging.rb

@@ -0,0 +1,112 @@
+require 'enkidu/dispatcher'
+require 'enkidu/tools'
+
+module Enkidu
+
+
+
+
+  class LogSource
+
+    attr_reader :defaults
+
+
+    def initialize(d, defaults:{})
+      @defaults = defaults
+      @dispatcher = d
+    end
+
+
+    def log(atts)
+      atts = Enkidu.deep_merge(defaults, atts)
+      path = atts[:type] || atts['type'] || 'log'
+      dispatcher.signal(path, atts)
+    end
+
+    def info(atts)
+      log(Enkidu.deep_merge({tags: ['INFO']}, atts))
+    end
+
+    def error(atts)
+      log(Enkidu.deep_merge({tags: ['ERROR']}, 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}
+      if e.respond_to?(:cause) && e.cause
+        atts[:exception][:cause] = {type: e.cause.class.name, message: e.cause.message, stacktrace: e.cause.backtrace}
+      end
+
+      log atts
+    end
+
+    def tail(pattern='#', &b)
+      dispatcher.on("log.#{pattern}", b)
+    end
+
+
+  private
+
+    def dispatcher
+      @dispatcher
+    end
+
+
+  end#class LogSource
+
+
+
+
+  class LogSink
+
+    attr_reader :filter
+
+    def initialize(d, io:, filter: 'log.#', formatter: nil)
+      @dispatcher = d
+      @io = io
+      @filter = filter
+      @formatter = formatter
+      run
+    end
+
+    def run
+      dispatcher.on filter do |msg|
+        log msg
+      end
+    end
+
+    def log(msg)
+      io.puts format(msg)
+    end
+
+    def format(msg)
+      formatter.call(msg)
+    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
+    end
+
+
+  private
+
+    def dispatcher
+      @dispatcher
+    end
+
+    def io
+      @io
+    end
+
+  end#class LogSink
+
+
+
+
+end#module Enkidu

data/lib/enkidu/signals.rb

@@ -0,0 +1,76 @@
+require 'thread'
+
+module Enkidu
+
+
+
+
+  # A SignalSource will trap signals and put handlers on a Dispatcher's queue instead
+  # of handling the signal immediately.
+  #
+  #   d = ThreadedDispatcher.new
+  #
+  #   s = SignalSource.new(d)
+  #   s.on 'INT', 'TERM' do |sig|
+  #     puts "Received #{sig}, cleaning up and shutting down"
+  #     d.stop
+  #   end
+  #
+  #   d.join
+  class SignalSource
+
+    SIGNALS = Signal.list
+
+
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+      @q = Queue.new
+      run
+    end
+
+    def run
+      Thread.new do
+        loop do
+          sig = @q.pop
+          dispatcher.signal("signal.#{sig}", sig)
+        end
+      end
+    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)
+      end
+      register *signals
+    end
+    alias trap on
+
+    def register(*signals)
+      signals.each do |signal|
+        Signal.trap(signal){ @q.push signal } #TODO not reentrant
+      end
+    end
+
+
+    SIGNALS.each do |name, number|
+      define_method "on_#{name.downcase}" do |callable: nil, &b|
+        on(name, callable:callable, &b)
+      end
+    end
+
+  private
+
+    def dispatcher
+      @dispatcher
+    end
+
+
+  end#class SignalSource
+
+
+
+
+end#module Enkidu

data/lib/enkidu/tools.rb

@@ -0,0 +1,51 @@
+module Enkidu
+
+
+  # Recursive (deep) merge of hashes and arrays
+  #
+  # For a hash, each key in o2 is merged onto a copy of o1. If the value is
+  # a hash or an array, it is itself deep_merged before it is added.
+  #
+  # For arrays, a copy of o1 is made, then each value in n2 not equal to the same
+  # position in n1 is pushed onto the copy. When both values are arrays or hashes,
+  # they are deep_merged onto the same position as before.
+  #
+  # deep_merge({foo: 'bar', bingo: 'dingo'}, {baz: 'quux', bingo: 'bongo'})
+  # => {foo: 'bar', bingo: 'bongo', baz: 'quux'}
+  #
+  # deep_merge([1, 2 {horse: 'donkey'}], [3, 4, {horse: 'rabbit', cat: 'dog'}])
+  # #=> [1, 2, {horse: 'rabbit', cat: 'dog'}, 3, 4]
+  def self.deep_merge(o1, o2)
+    if Hash === o1 && Hash === o2
+      res = o1.dup
+      o2.each do |k, nv|
+        ov = res[k]
+        res[k] = if Hash === ov && Hash === nv
+                   deep_merge(ov, nv)
+                 elsif Array === ov && Array === nv
+                   deep_merge(ov, nv)
+                 else
+                   nv
+                 end
+      end
+    elsif Array === o1 && Array === o2
+      res = o1.dup
+      nvals = []
+      o2.each_with_index do |nv, i|
+        ov = res[i]
+        if (Hash === ov && Hash === nv) || (Array === ov && Array === nv)
+          res[i] = deep_merge(ov, nv)
+        elsif ov != nv
+          nvals << nv
+        end
+      end
+      res.concat(nvals)
+    else
+      raise
+    end
+
+    res
+  end
+
+
+end#module Enkidu

data/lib/enkidu.rb

@@ -0,0 +1,7 @@
+# Enkidu - a process sidekick
+module Enkidu
+end#module Enkidu
+
+require 'enkidu/dispatcher'
+require 'enkidu/signals'
+require 'enkidu/logging'

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: enkidu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tore Darell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-06 00:00:00.000000000 Z
+dependencies: []
+description: Enkidu is a process sidekick
+email: toredarell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/enkidu.rb
+- lib/enkidu/dispatcher.rb
+- lib/enkidu/logging.rb
+- lib/enkidu/signals.rb
+- lib/enkidu/tools.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Enkidu process sidekick
+test_files: []