schleyfox-ernie 2.2.1

data/examples/ext.rb

@@ -0,0 +1,39 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ernie'
+
+module Ext
+  # 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
+
+Ernie.expose(:ext, Ext)

data/examples/nat.erl

@@ -0,0 +1,12 @@
+-module(nat).
+-export([add/2, fib/1, die/1]).
+
+add(A, B) ->
+  A + B.
+
+fib(0) -> 1;
+fib(1) -> 1;
+fib(N) when N > 1 -> fib(N - 1) + fib(N - 2).
+
+die(X) ->
+  X = 10.

data/ext/Makefile

@@ -0,0 +1,2 @@
+install:
+	erlc -o ../ebin ../elib/*.erl

data/ext/extconf.rb

@@ -0,0 +1 @@
+# does nothing, Makefile is handwritten

data/lib/ernie.rb

@@ -0,0 +1,225 @@
+require 'rubygems'
+require 'bert'
+require 'logger'
+
+class Ernie
+  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
+    })
+    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}'"))
+    self.mods[mod].funs[fun].call(*args)
+  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")
+    self.log.debug(self.mods.inspect)
+
+    input = IO.new(3)
+    output = IO.new(4)
+    input.sync = true
+    output.sync = true
+
+    loop do
+      self.procline('waiting')
+      iruby = self.read_berp(input)
+      self.count += 1
+
+      unless iruby
+        puts "Could not read BERP length header. Ernie server may have gone away. Exiting now."
+        self.log.info("(#{Process.pid}) Could not read BERP length header. Ernie server may have gone away. Exiting now.")
+        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)
+        begin
+          res = self.dispatch(mod, fun, args)
+          oruby = t[:reply, res]
+          self.log.debug("<- " + oruby.inspect)
+          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)
+          self.log.error(e.backtrace.join("\n"))
+          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)
+          self.log.error(e.backtrace.join("\n"))
+          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)
+        begin
+          self.dispatch(mod, fun, args)
+        rescue Object => e
+          # ignore
+        end
+        write_berp(output, t[:noreply])
+      else
+        self.procline("invalid request")
+        self.log.error("-> " + iruby.inspect)
+        oruby = t[:error, t[:server, 0, "Invalid request: #{iruby.inspect}"]]
+        self.log.error("<- " + oruby.inspect)
+        write_berp(output, oruby)
+      end
+    end
+  end
+
+  def self.procline(msg)
+    $0 = "ernie handler #{VERSION} (ruby) - #{self.virgin_procline} - [#{self.count}] #{msg}"[0..159]
+  end
+
+  def self.version
+    yml = YAML.load(File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION.yml])))
+    "#{yml[:major]}.#{yml[:minor]}.#{yml[:patch]}"
+  rescue
+    'unknown'
+  end
+
+  VERSION = self.version
+end
+
+class Ernie::ServerError < StandardError; end
+
+class Ernie::Mod
+  attr_accessor :name, :funs
+
+  def initialize(name)
+    self.name = name
+    self.funs = {}
+  end
+
+  def fun(name, block)
+    raise TypeError, "block required" if block.nil?
+    self.funs[name] = block
+  end
+end
+
+# Root level calls
+
+def logfile(name)
+  Ernie.logfile(name)
+end
+
+def loglevel(level)
+  Ernie.loglevel(level)
+end
+
+at_exit do
+  Ernie.start if Ernie.auto_start
+end

data/test/ernie_server_test.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/helper'
+
+PORT = 27118
+
+class ErnieServerTest < Test::Unit::TestCase
+  context "An Ernie Server" do
+    setup do
+      `#{ERNIE_ROOT}/bin/ernie -c #{ERNIE_ROOT}/test/sample/sample.cfg \
+                               -P /tmp/ernie.pid \
+                               -p #{PORT} \
+                               -d`
+      @svc = BERTRPC::Service.new('localhost', PORT)
+      loop do
+        begin
+          @svc.call.ext.zeronary
+          break
+        rescue Object => e
+          sleep 0.1
+        end
+      end
+    end
+
+    context "call" do
+      should "handle zeronary" do
+        assert_equal :foo, @svc.call.ext.zeronary
+      end
+
+      should "handle unary" do
+        assert_equal 5, @svc.call.ext.unary(5)
+      end
+
+      should "handle binary" do
+        assert_equal 7, @svc.call.ext.binary(5, 2)
+      end
+
+      should "handle ternary" do
+        assert_equal 10, @svc.call.ext.ternary(5, 2, 3)
+      end
+
+      should "handle massive binaries" do
+        assert_equal 8 * 1024 * 1024, @svc.call.ext.big(8 * 1024 * 1024).size
+      end
+
+      should "get an error on missing module" do
+        begin
+          @svc.call.failboat.mcfail(:fail)
+          fail "Expected a BERTRPC::ServerError"
+        rescue BERTRPC::ServerError => e
+          assert_equal "No such module 'failboat'", e.message
+        end
+      end
+
+      should "get an error on missing function" do
+        begin
+          @svc.call.ext.mcfail(:fail)
+          fail "Expected a BERTRPC::ServerError"
+        rescue BERTRPC::ServerError => e
+          assert_equal "No such function 'ext:mcfail'", e.message
+        end
+      end
+    end
+
+    context "cast" do
+      should "be received and return immediately" do
+        t0 = Time.now
+        assert_equal nil, @svc.cast.ext.set_state(7)
+        assert Time.now - t0 < 1
+        assert_equal 7, @svc.call.ext.get_state
+      end
+    end
+
+    teardown do
+      pid = File.read('/tmp/ernie.pid')
+      `kill -9 #{pid}`
+    end
+  end
+end

data/test/ernie_test.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ErnieTest < 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 { Ernie.expose :expo, TestExposingModule }
+    teardown { Ernie.mods.clear }
+
+    should "add all public methods from the module" do
+      assert_not_nil Ernie.mods[:expo].funs[:foo]
+      assert_not_nil Ernie.mods[:expo].funs[:bar]
+    end
+
+    should "not expose protected methods" do
+      assert_nil Ernie.mods[:expo].funs[:baz]
+    end
+
+    should "not expose private methods" do
+      assert_nil Ernie.mods[:expo].funs[:bling]
+    end
+
+    should "dispatch to module methods properly" do
+      res = Ernie.dispatch(:expo, :bar, ['a', :b, { :fiz => 42 }])
+      assert_equal ['a', :b, { :fiz => 42 }], res
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+ERNIE_ROOT = File.join(File.dirname(__FILE__), *%w[..])
+
+$:.unshift(File.join(ERNIE_ROOT, 'lib'))
+
+require 'ernie'
+Ernie.auto_start = false
+
+begin
+  require 'bertrpc'
+rescue LoadError
+  puts "You need bertrpc gem installed to run tests."
+  exit!(1)
+end

data/test/load.rb

@@ -0,0 +1,18 @@
+require 'bertrpc'
+
+$stdout.sync = true
+
+threads = []
+svc = BERTRPC::Service.new('localhost', 8000)
+
+8.times do
+  threads << Thread.new do
+    i = 0
+    10.times { i += svc.call.calc.add(1, 2); print '.'; $stdout.flush }
+    print "(#{i})"
+  end
+end
+
+threads.each { |t| t.join }
+
+puts

data/test/sample/ext.rb

@@ -0,0 +1,42 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require 'ernie'
+
+module Ext
+  @@state = 0
+
+  def zeronary
+    :foo
+  end
+
+  def unary(a)
+    a
+  end
+
+  def binary(a, b)
+    a + b
+  end
+
+  def ternary(a, b, c)
+    a + b + c
+  end
+
+  def set_state(x)
+    @@state = x
+    sleep 5
+    nil
+  end
+
+  def get_state
+    @@state
+  end
+
+  def big(x)
+    'a' * x
+  end
+
+  def cry
+    raise "abandon hope!"
+  end
+end
+
+Ernie.expose(:ext, Ext)

data/test/sample/sample.cfg

@@ -0,0 +1,4 @@
+[{module, ext},
+ {type, external},
+ {command, "ruby /Users/tom/dev/mojombo/ernie/test/sample/ext.rb"},
+ {count, 1}].

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: schleyfox-ernie
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 2
+  - 2
+  - 1
+  version: 2.2.1
+platform: ruby
+authors: 
+- Tom Preston-Werner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-12 00:00:00 -05:00
+default_executable: ernie
+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
+description: Ernie is an Erlang/Ruby hybrid BERT-RPC server implementation packaged as a gem.
+email: tom@mojombo.com
+executables: 
+- ernie
+extensions: 
+- ext/extconf.rb
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- History.txt
+- LICENSE
+- README.md
+- Rakefile
+- VERSION.yml
+- bin/ernie
+- contrib/ebench.erl
+- ebin/ernie_server_app.app
+- elib/asset_pool.erl
+- elib/asset_pool_sup.erl
+- elib/bert.erl
+- elib/ernie.hrl
+- elib/ernie_access_logger.erl
+- elib/ernie_access_logger_sup.erl
+- elib/ernie_admin.erl
+- elib/ernie_config.erl
+- elib/ernie_native.erl
+- elib/ernie_server.erl
+- elib/ernie_server_app.erl
+- elib/ernie_server_sup.erl
+- elib/logger.erl
+- elib/logger_sup.erl
+- elib/port_wrapper.erl
+- ernie.gemspec
+- examples/example.cfg
+- examples/ext.erl
+- examples/ext.rb
+- examples/nat.erl
+- ext/Makefile
+- ext/extconf.rb
+- lib/ernie.rb
+- test/ernie_server_test.rb
+- test/ernie_test.rb
+- test/helper.rb
+- test/load.rb
+- test/sample/ext.rb
+- test/sample/sample.cfg
+has_rdoc: true
+homepage: http://github.com/mojombo/ernie
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: ernie
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Ernie is a BERT-RPC server implementation.
+test_files: 
+- test/ernie_server_test.rb
+- test/ernie_test.rb
+- test/helper.rb
+- test/load.rb
+- test/sample/ext.rb
+- examples/ext.rb