ernicorn 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+/.bundle
+/bin
+/vendor

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tom Preston-Werner, Aman Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+Ernicorn
+========
+
+A BERT-RPC server based on [Ernie](https://github.com/mojombo/ernie)'s Ruby
+interface but that uses [Unicorn](http://unicorn.bogomips.org/) for worker
+process management.
+
+Ernicorn supports BERT-RPC `call` and `cast` requests. See the full BERT-RPC
+specification at [bert-rpc.org](http://bert-rpc.org) for more information.
+
+Like Ernie before it, Ernicorn was developed at GitHub and is currently in
+production use serving millions of RPC requests every day.
+
+Installation
+------------
+
+    $ gem install ernicorn
+
+Starting The Server
+-------------------
+
+Use the ernicorn command to start a new RPC server:
+
+    [rtomayko@iron:ernicorn]$ ernicorn --help
+    Ernicorn is an Ruby BERT-RPC Server based on Unicorn.
+
+    Basic Command Line Usage:
+      ernicorn [options] <handler>
+
+        -c, --config CONFIG              Unicorn style config file
+        -p, --port PORT                  Port
+        -l, --log-level LOGLEVEL         Log level (0-4)
+        -d, --detached                   Run as a daemon
+        -P, --pidfile PIDFILE            Location to write pid file.
+
+The handler must be given and should be a normal Ruby file that sets up the
+environment and calls `Ernicorn.expose` for any server modules. See the
+[examples/handler.rb][h] file for more info.
+
+[h]: https://github.com/github/ernicorn/blob/master/examples/handler.rb
+
+Control Commands
+----------------
+
+The `ernicorn-ctrl` command can be used to send various control and
+informational commands to the running server process:
+
+    $ ernicorn-ctrl --help
+    Usage: ernicorn-ctrl [-p <port>] <command>
+    Issue a control command to an ernicorn server. The port option is used to
+    specify a non-default control port.
+
+    Commands:
+      reload-handlers         Gracefully reload all handler processes.
+      stats                   Dump handler stats for the server.
+      halt                    Shut down.
+
+Ernicorn servers also support most Unicorn signals for managing worker processes
+and whatnot. See the [SIGNALS](http://unicorn.bogomips.org/SIGNALS.html) file
+for more info.
+
+Development
+-----------
+
+The `script/bootstrap` command is provided to setup a local gem environment for
+development.
+
+    $ script/bootstrap
+
+It installs all gems under `vendor/gems` and creates binstubs under a `bin`
+directory. This is the best way to get setup for running tests and experimenting
+in a sandbox.

data/Rakefile

@@ -0,0 +1,8 @@
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end

data/ernicorn.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.6'
+
+  s.name = 'ernicorn'
+  s.version = '1.0.0'
+  s.date = '2012-06-23'
+
+  s.summary     = "Ernicorn is a BERT-RPC server implementation based on unicorn."
+  s.description = "Ernicorn is a BERT-RPC server packaged as a gem."
+
+  s.authors  = ["Tom Preston-Werner", "tmm1", "rtomayko"]
+  s.email    = 'tmm1@github.com'
+  s.homepage = 'https://github.com/github/ernicorn'
+
+  s.add_runtime_dependency('bert', ">= 1.1.0")
+  s.add_runtime_dependency('bertrpc', ">= 1.0.0")
+  s.add_runtime_dependency('unicorn', "~> 4.1.1")
+
+  s.add_development_dependency('shoulda', "~> 2.11.3")
+
+  s.files         = `git ls-files`.split("\n") - %w[Gemfile Gemfile.lock]
+  s.test_files    = `git ls-files -- test`.split("\n").select { |f| f =~ /_test.rb$/ }
+
+  s.bindir        = "script"
+  s.executables   = %w[ernicorn ernicorn-ctrl]
+  s.require_paths = %w[lib]
+  s.extra_rdoc_files = %w[LICENSE README.md]
+end

data/examples/client.rb

@@ -0,0 +1,13 @@
+require 'bertrpc'
+service = BERTRPC::Service.new('localhost', 9777)
+
+loop do
+  begin
+    puts ">> add(10, 32)"
+    res = service.call.example.send(:add, 10, 32)
+    puts "=> #{res.inspect}"
+  rescue => boom
+    puts "ERROR: #{boom.class} #{boom}"
+  end
+  sleep 1
+end

data/examples/config.rb

@@ -0,0 +1,36 @@
+# Ernicorn configuration
+#
+# Ernicorn config files typically live at config/ernicorn.rb and support all
+# Unicorn config options:
+#
+#    http://unicorn.bogomips.org/Unicorn/Configurator.html
+#
+# Example unicorn config files:
+#
+#   http://unicorn.bogomips.org/examples/unicorn.conf.rb
+#   http://unicorn.bogomips.org/examples/unicorn.conf.minimal.rb
+warn "in unicorn config file: #{__FILE__}"
+
+# server options
+listen 9777
+worker_processes 2
+working_directory File.dirname(__FILE__)
+
+# ernicorn configuration
+Ernicorn.loglevel 1
+
+# enable COW where possible
+GC.respond_to?(:copy_on_write_friendly=) &&
+  GC.copy_on_write_friendly = true
+
+# load server code and expose modules
+require File.expand_path('../handler', __FILE__)
+Ernicorn.expose(:example, Example)
+
+# hook into new child immediately after forking
+after_fork  do |server, worker|
+end
+
+# hook into master immediately before forking a worker
+before_fork do |server, worker|
+end

data/examples/handler.rb

@@ -0,0 +1,49 @@
+# An example BERTRPC server module. To start the RPC server use:
+#
+#    $ bin/ernicorn -p 9675 examples/handler.rb
+#
+# Then connect and issue commands as follows:
+#
+#    $ script/console
+#    >> require 'bertrpc'
+#    >> service = BERTRPC::Service.new('localhost', 9675)
+#    => #<BERTRPC::Service:0x1037e9678 @port=9765, @timeout=nil, @host="localhost">
+#    >> service.call.example.send(:add, 1, 2)
+#    => 3
+#    >> service.call.example.send(:fib, 10)
+#    => 89
+
+module Example
+  # Add two numbers together
+  def add(a, b)
+    a + b
+  end
+
+  def fib(n)
+    if n == 0 || n == 1
+      1
+    else
+      fib(n - 1) + fib(n - 2)
+    end
+  end
+
+  def shadow(x)
+    "ruby"
+  end
+
+  # Return the given number of bytes
+  def bytes(n)
+    'x' * n
+  end
+
+  # Sleep for +sec+ and then return :ok
+  def slow(sec)
+    sleep(sec)
+    :ok
+  end
+
+  # Throw an error
+  def error
+    raise "abandon hope!"
+  end
+end

data/examples/start.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+# Start the example ernicorn server on port 9777.
+cd "$(dirname "$0")"
+exec ernicorn -p 9777 config.rb

data/lib/ernicorn/adminrpc.rb

@@ -0,0 +1,39 @@
+require 'unicorn'
+
+module Ernicorn
+  module AdminRPC
+    def stats
+      queued = active = 0
+
+      Raindrops::Linux.tcp_listener_stats(Unicorn.listener_names).each do |addr,stats|
+        queued += stats.queued
+        active += stats.active
+      end if defined?(Raindrops::Linux.tcp_listener_stats)
+
+      return <<STATS
+connections.total=#{Stats.connections_total}
+connections.completed=#{Stats.connections_completed}
+workers.idle=#{Stats.workers_idle}
+workers.busy=#{active}
+queue.high=#{queued}
+queue.low=0
+STATS
+    end
+
+    def reload_handlers
+      Process.kill 'USR2', master_pid
+      "Sent USR2 to #{master_pid}"
+    end
+
+    def halt
+      Process.kill 'QUIT', master_pid
+      "Sent QUIT to #{master_pid}"
+    end
+
+    def master_pid
+      $ernicorn.master_pid
+    end
+  end
+end
+
+Ernicorn.expose(:__admin__, Ernicorn::AdminRPC)

data/lib/ernicorn/server.rb

@@ -0,0 +1,82 @@
+require 'unicorn'
+
+module Ernicorn
+  Stats = Raindrops::Struct.new(:connections_total,
+                                :connections_completed,
+                                :workers_idle).new
+
+  class Server < Unicorn::HttpServer
+
+    # Private HttpServer methods we're overriding to
+    # implement BertRPC instead of HTTP.
+
+    def initialize(app, options={})
+      super app, options
+    end
+
+    def build_app!
+    end
+
+    def worker_loop(worker)
+      Stats.incr_workers_idle
+
+      if worker.nr == (self.worker_processes - 1)
+        old_pid = "#{self.pid}.oldbin"
+        if File.exists?(old_pid) && self.pid != old_pid
+          begin
+            Process.kill("QUIT", File.read(old_pid).to_i)
+          rescue Errno::ENOENT, Errno::ESRCH
+            # someone else did our job for us
+          end
+        end
+      end
+
+      super
+    ensure
+      Stats.decr_workers_idle
+    end
+
+    def process_client(client)
+      Stats.decr_workers_idle
+      Stats.incr_connections_total
+
+      @client = client
+      # bail out if client only sent EOF
+      return if @client.kgio_trypeek(1).nil?
+
+      iruby, oruby = Ernicorn.process(self, self)
+    rescue EOFError
+      logger.error("EOF from #{@client.kgio_addr rescue nil}")
+    rescue Object => e
+      logger.error(e)
+
+      begin
+        error = t[:error, t[:server, 0, e.class.to_s, e.message, e.backtrace]]
+        Ernicorn.write_berp(self, error)
+      rescue Object => ex
+        logger.error(ex)
+      end
+    ensure
+      @client.close rescue nil
+      @client = nil
+
+      Stats.incr_connections_completed
+      Stats.incr_workers_idle
+    end
+
+    # We pass ourselves as both input and output to Ernicorn.process, which
+    # calls the following blocking read/write methods.
+
+    def read(len)
+      data = ''
+      while data.bytesize < len
+        data << @client.kgio_read!(len - data.bytesize)
+      end
+      data
+    end
+
+    def write(data)
+      @client.kgio_write(data)
+    end
+  end
+end

data/lib/ernicorn.rb

@@ -0,0 +1,252 @@
+require 'bert'
+require 'logger'
+
+module Ernicorn
+  VERSION = '1.0.0'
+
+  class << self
+    attr_accessor :mods, :current_mod, :log
+    attr_accessor :auto_start
+    attr_accessor :count, :virgin_procline
+  end
+
+  self.count = 0
+  self.virgin_procline = $0
+  self.mods = {}
+  self.current_mod = nil
+  self.log = Logger.new(STDOUT)
+  self.log.level = Logger::FATAL
+  self.auto_start = true
+
+  # Record a module.
+  #   +name+ is the module Symbol
+  #   +block+ is the Block containing function definitions
+  #
+  # Returns nothing
+  def self.mod(name, block)
+    m = Mod.new(name)
+    self.current_mod = m
+    self.mods[name] = m
+    block.call
+  end
+
+  # Record a function.
+  #   +name+ is the function Symbol
+  #   +block+ is the Block to associate
+  #
+  # Returns nothing
+  def self.fun(name, block)
+    self.current_mod.fun(name, block)
+  end
+
+  # Expose all public methods in a Ruby module:
+  #   +name+ is the ernie module Symbol
+  #   +mixin+ is the ruby module whose public methods are exposed
+  #
+  # Returns nothing
+  def self.expose(name, mixin)
+    context = Object.new
+    context.extend mixin
+    mod(name, lambda {
+      mixin.public_instance_methods.each do |meth|
+        fun(meth.to_sym, context.method(meth))
+      end
+    })
+    if defined? mixin.dispatched
+      self.current_mod.logger = mixin.method(:dispatched)
+    end
+    context
+  end
+
+  # Set the logfile to given path.
+  #   +file+ is the String path to the logfile
+  #
+  # Returns nothing
+  def self.logfile(file)
+    self.log = Logger.new(file)
+  end
+
+  # Set the log level.
+  #   +level+ is the Logger level (Logger::WARN, etc)
+  #
+  # Returns nothing
+  def self.loglevel(level)
+    self.log.level = level
+  end
+
+  # Dispatch the request to the proper mod:fun.
+  #   +mod+ is the module Symbol
+  #   +fun+ is the function Symbol
+  #   +args+ is the Array of arguments
+  #
+  # Returns the Ruby object response
+  def self.dispatch(mod, fun, args)
+    self.mods[mod] || raise(ServerError.new("No such module '#{mod}'"))
+    self.mods[mod].funs[fun] || raise(ServerError.new("No such function '#{mod}:#{fun}'"))
+
+    start = Time.now
+    ret = self.mods[mod].funs[fun].call(*args)
+
+    begin
+      self.mods[mod].logger and
+      self.mods[mod].logger.call(Time.now-start, [fun, *args], ret)
+    rescue Object => e
+      self.log.fatal(e)
+    end
+
+    ret
+  end
+
+  # Read the length header from the wire.
+  #   +input+ is the IO from which to read
+  #
+  # Returns the size Integer if one was read
+  # Returns nil otherwise
+  def self.read_4(input)
+    raw = input.read(4)
+    return nil unless raw
+    raw.unpack('N').first
+  end
+
+  # Read a BERP from the wire and decode it to a Ruby object.
+  #   +input+ is the IO from which to read
+  #
+  # Returns a Ruby object if one could be read
+  # Returns nil otherwise
+  def self.read_berp(input)
+    packet_size = self.read_4(input)
+    return nil unless packet_size
+    bert = input.read(packet_size)
+    BERT.decode(bert)
+  end
+
+  # Write the given Ruby object to the wire as a BERP.
+  #   +output+ is the IO on which to write
+  #   +ruby+ is the Ruby object to encode
+  #
+  # Returns nothing
+  def self.write_berp(output, ruby)
+    data = BERT.encode(ruby)
+    output.write([data.length].pack("N"))
+    output.write(data)
+  end
+
+  # Start the processing loop.
+  #
+  # Loops forever
+  def self.start
+    self.procline('starting')
+    self.log.info("(#{Process.pid}) Starting") if self.log.level <= Logger::INFO
+    self.log.debug(self.mods.inspect) if self.log.level <= Logger::DEBUG
+
+    input = IO.new(3)
+    output = IO.new(4)
+    input.sync = true
+    output.sync = true
+
+    loop do
+      process(input, output)
+    end
+  end
+
+  # Processes a single BertRPC command.
+  #
+  #   input  - The IO to #read command BERP from.
+  #   output - The IO to #write reply BERP to.
+  #
+  # Returns a [iruby, oruby] tuple of incoming and outgoing BERPs processed.
+  def self.process(input, output)
+    self.procline('waiting')
+    iruby = self.read_berp(input)
+    self.count += 1
+
+    unless iruby
+      puts "Could not read BERP length header. Ernicorn server may have gone away. Exiting now."
+      if self.log.level <= Logger::INFO
+        self.log.info("(#{Process.pid}) Could not read BERP length header. Ernicorn server may have gone away. Exiting now.")
+      end
+      exit!
+    end
+
+    if iruby.size == 4 && iruby[0] == :call
+      mod, fun, args = iruby[1..3]
+      self.procline("#{mod}:#{fun}(#{args})")
+      self.log.info("-> " + iruby.inspect) if self.log.level <= Logger::INFO
+      begin
+        res = self.dispatch(mod, fun, args)
+        oruby = t[:reply, res]
+        self.log.debug("<- " + oruby.inspect) if self.log.level <= Logger::DEBUG
+        write_berp(output, oruby)
+      rescue ServerError => e
+        oruby = t[:error, t[:server, 0, e.class.to_s, e.message, e.backtrace]]
+        self.log.error("<- " + oruby.inspect) if self.log.level <= Logger::ERROR
+        self.log.error(e.backtrace.join("\n")) if self.log.level <= Logger::ERROR
+        write_berp(output, oruby)
+      rescue Object => e
+        oruby = t[:error, t[:user, 0, e.class.to_s, e.message, e.backtrace]]
+        self.log.error("<- " + oruby.inspect) if self.log.level <= Logger::ERROR
+        self.log.error(e.backtrace.join("\n")) if self.log.level <= Logger::ERROR
+        write_berp(output, oruby)
+      end
+    elsif iruby.size == 4 && iruby[0] == :cast
+      mod, fun, args = iruby[1..3]
+      self.procline("#{mod}:#{fun}(#{args})")
+      self.log.info("-> " + [:cast, mod, fun, args].inspect) if self.log.level <= Logger::INFO
+      oruby = t[:noreply]
+      write_berp(output, oruby)
+
+      begin
+        self.dispatch(mod, fun, args)
+      rescue Object => e
+        # ignore
+      end
+    else
+      self.procline("invalid request")
+      self.log.error("-> " + iruby.inspect) if self.log.level <= Logger::ERROR
+      oruby = t[:error, t[:server, 0, "Invalid request: #{iruby.inspect}"]]
+      self.log.error("<- " + oruby.inspect) if self.log.level <= Logger::ERROR
+      write_berp(output, oruby)
+    end
+
+    self.procline('waiting')
+    [iruby, oruby]
+  end
+
+  def self.procline(msg)
+    $0 = "ernicorn handler #{VERSION} (ruby) - #{self.virgin_procline} - [#{self.count}] #{msg}"[0..159]
+  end
+
+  def self.version
+    VERSION
+  end
+
+  class ServerError < StandardError; end
+
+  class Ernicorn::Mod
+    attr_accessor :name, :funs, :logger
+
+    def initialize(name)
+      self.name = name
+      self.funs = {}
+      self.logger = nil
+    end
+
+    def fun(name, block)
+      raise TypeError, "block required" if block.nil?
+      self.funs[name] = block
+    end
+  end
+end
+# Root level calls
+
+def logfile(name)
+  Ernicorn.logfile(name)
+end
+
+def loglevel(level)
+  Ernicorn.loglevel(level)
+end
+
+at_exit do
+  Ernicorn.start if Ernicorn.auto_start && !defined?(Ernicorn)
+end

data/script/bootstrap

@@ -0,0 +1,11 @@
+#!/bin/sh
+# Usage: script/bootstrap [--local]
+# Prepare the local gem environment.
+set -e
+
+cd "$(dirname "$0")/.."
+if bundle check 1>/dev/null 2>&1; then
+    echo "Gem environment up-to-date"
+else
+    exec bundle install --binstubs --path vendor/gems "$@"
+fi

data/script/cibuild

@@ -0,0 +1,23 @@
+#!/bin/sh
+# Usage: script/cibuild
+# CI build script.
+# This is tailored for the janky build machines.
+set -e
+
+# change into root dir and setup path
+cd $(dirname "$0")/..
+PATH="$(pwd)/bin:$(pwd)/script:/usr/share/rbenv/shims:$PATH"
+
+# Write commit we're building at
+git log -n 1 || true
+echo
+
+echo "Building under 1.8.7"
+bootstrap
+testsuite
+echo
+
+echo "Building under 1.9.3"
+export RBENV_VERSION="${1:-1.9.3-p0}"
+bootstrap
+testsuite

data/script/ernicorn

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+#/ Usage: ernicorn [options] [config file]
+#/ Start a Ruby BERT-RPC Server with the given options and config file.
+#/
+#/ Options
+#/   -h, --host=<host>          Server address to listen on; default: 0.0.0.0
+#/   -p, --port=<portno>        Server port to listen on; default: 8000
+#/       --log-level=0-4        Set the log level
+#/   -d, --detached             Run as a daemon
+#/   -P, --pidfile=<file>       Location to write pid file
+#/
+#/ See https://github.com/github/ernicorn for more information.
+require 'optparse'
+require 'ernicorn'
+require 'ernicorn/server'
+require 'ernicorn/adminrpc'
+
+Ernicorn.auto_start = false
+
+host = '0.0.0.0'
+port = 8000
+daemonize = false
+config = 'config/ernicorn.rb'
+pidfile = nil
+
+parser = OptionParser.new do |opts|
+  opts.on("-c", "--config=val", String)     { |config| }
+  opts.on("-h", "--host=val", Integer)      { |host| }
+  opts.on("-p", "--port=val", Integer)      { |port| }
+  opts.on(      "--log-level=val", Integer) { |val| Ernicorn.loglevel(val) }
+  opts.on("-d", "--detached")               { |daemonize| }
+  opts.on("-P", "--pidfile=val")            { |pidfile| }
+  opts.on_tail("-h", "--help")              { exec "grep ^#/<'#{__FILE__}'|cut -c4-" }
+  opts.parse!
+end
+
+config = ARGV[0] || config
+
+options = {
+  :pid         => pidfile,
+  :listeners   => ["#{host}:#{port}"],
+  :config_file => File.expand_path(config)
+}
+
+if daemonize
+  require 'unicorn/launcher'
+  Unicorn::Launcher.daemonize!(options)
+end
+
+$ernicorn = Ernicorn::Server.new(nil, options)
+$ernicorn.start.join

data/script/ernicorn-ctrl

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+#/ Usage: ernicorn-ctrl [-p <port>] <command>
+#/ Issue a control command to an ernicorn server. The port option is used to
+#/ specify a non-default control port.
+#/
+#/ Commands:
+#/   reload-handlers         Gracefully reload all handler processes.
+#/   stats                   Dump handler stats for the server.
+#/   halt                    Shut down.
+require 'optparse'
+require 'bertrpc'
+
+port = 8000
+
+def usage(status=0)
+  exec "grep ^#/<'#{__FILE__}'|cut -c4-; exit #{status}"
+end
+
+# parse arguments
+ARGV.options do |opts|
+  opts.on("-p", "--port=val", Integer) { |port| }
+  opts.on_tail("-h", "--help")         { usage }
+  opts.parse!
+end
+
+# the control command
+command = ARGV[0]
+
+# bail out with usage if the command wasn't specified or is invalid
+if !%w[reload-handlers stats halt].include?(command)
+  usage(1)
+end
+
+# connect to the adminrpc handler and send the command
+require 'bertrpc'
+service = BERTRPC::Service.new('localhost', port)
+puts service.call.__admin__.send(command.gsub(/-/, '_'))

data/script/testsuite

@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+cd "$(dirname "$0")/.."
+
+# run entire test suite
+ruby --version 1>&2
+bundle exec ruby -I "$(pwd)" -e "ARGV.each { |f| require(f) }" -- $(find test -name 'test_*.rb')

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+require 'shoulda'
+require 'ernicorn'
+Ernicorn.auto_start = false

data/test/test_ernicorn.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../helper', __FILE__)
+
+class ErnicornTest < Test::Unit::TestCase
+  module TestExposingModule
+    def foo
+    end
+
+    def bar(a, b, c=nil)
+      [a, b, c]
+    end
+
+  protected
+    def baz
+    end
+
+  private
+    def bling
+    end
+  end
+
+  context "expose" do
+    setup { Ernicorn.expose :expo, TestExposingModule }
+    teardown { Ernicorn.mods.clear }
+
+    should "add all public methods from the module" do
+      assert_not_nil Ernicorn.mods[:expo].funs[:foo]
+      assert_not_nil Ernicorn.mods[:expo].funs[:bar]
+    end
+
+    should "not expose protected methods" do
+      assert_nil Ernicorn.mods[:expo].funs[:baz]
+    end
+
+    should "not expose private methods" do
+      assert_nil Ernicorn.mods[:expo].funs[:bling]
+    end
+
+    should "dispatch to module methods properly" do
+      res = Ernicorn.dispatch(:expo, :bar, ['a', :b, { :fiz => 42 }])
+      assert_equal ['a', :b, { :fiz => 42 }], res
+    end
+  end
+
+  module TestLoggingModule
+    def self.logs() @logs ||= [] end
+
+    def self.dispatched(*args)
+      logs << args
+    end
+
+    def sleepy(time)
+      sleep(time)
+      time
+    end
+  end
+
+  context "logging" do
+    setup { Ernicorn.expose :logging, TestLoggingModule; TestLoggingModule.logs.clear  }
+    teardown { Ernicorn.mods.clear }
+
+    should "call logger method with timing" do
+      ret = Ernicorn.dispatch(:logging, :sleepy, 0.1)
+      assert_equal 0.1, ret
+
+      assert_equal 1, TestLoggingModule.logs.size
+      assert_in_delta 0.1, TestLoggingModule.logs.first[0], 0.05
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: ernicorn
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tom Preston-Werner
+- tmm1
+- rtomayko
+autorequire: 
+bindir: script
+cert_chain: []
+
+date: 2012-06-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bert
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bertrpc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: unicorn
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 4
+        - 1
+        - 1
+        version: 4.1.1
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 11
+        - 3
+        version: 2.11.3
+  type: :development
+  version_requirements: *id004
+description: Ernicorn is a BERT-RPC server packaged as a gem.
+email: tmm1@github.com
+executables: 
+- ernicorn
+- ernicorn-ctrl
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- ernicorn.gemspec
+- examples/client.rb
+- examples/config.rb
+- examples/handler.rb
+- examples/start.sh
+- lib/ernicorn.rb
+- lib/ernicorn/adminrpc.rb
+- lib/ernicorn/server.rb
+- script/bootstrap
+- script/cibuild
+- script/ernicorn
+- script/ernicorn-ctrl
+- script/testsuite
+- test/helper.rb
+- test/test_ernicorn.rb
+has_rdoc: true
+homepage: https://github.com/github/ernicorn
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: Ernicorn is a BERT-RPC server implementation based on unicorn.
+test_files: []
+