mojombo-ernie 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.md
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,2 @@
+*.beam
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tom Preston-Werner
+
+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,79 @@
+Ernie
+=====
+
+By Tom Preston-Werner (tom@mojombo.com)
+
+WARNING: This software is alpha and should not be used in production without
+extensive testing. You should not consider this project production ready until
+it is released as 1.0.
+
+
+Description
+-----------
+
+Ernie is a BERT-RPC server implementation that uses an Erlang server to accept incoming connections, and then delegates the request to a Ruby handler via Erlectricity.
+
+
+Installation
+------------
+
+  You must have Erlang installed before installing Ernie.
+
+    gem install mojombo-ernie -s http://gems.github.com
+
+
+Running
+-------
+
+    Usage: ernie [options] <handler>
+        -n, --name NAME                  Node name
+        -p, --port PORT                  Port
+        -d, --detached                   Run as a daemon
+        -P, --pidfile PIDFILE            Location to write pid file.
+
+
+Example Handler
+---------------
+
+    require 'ernie'
+    
+    mod(:calc) do
+      fun(:add) do |a, b|
+        a + b
+      end
+    end
+
+
+Example BERT-RPC call for above example
+---------------------------------------
+
+    -> {call, calc, add, [1, 2]}
+    
+    <- {reply, 3}
+
+
+Contribute
+----------
+
+If you'd like to hack on Ernie, start by forking my repo on GitHub:
+
+http://github.com/mojombo/ernie
+
+To get all of the dependencies, install the gem first. The best way to get
+your changes merged back into core is as follows:
+
+1. Clone down your fork
+1. Create a topic branch to contain your change
+1. Hack away
+1. Add tests and make sure everything still passes by running `rake`
+1. If you are adding new functionality, document it in the README.md
+1. Do not change the version number, I will do that on my end
+1. If necessary, rebase your commits into logical chunks, without errors
+1. Push the branch up to GitHub
+1. Send me (mojombo) a pull request for your branch
+
+
+Copyright
+---------
+
+Copyright (c) 2009 Tom Preston-Werner. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ernie"
+    gem.summary = %Q{TODO}
+    gem.email = "tom@mojombo.com"
+    gem.homepage = "http://github.com/mojombo/ernie"
+    gem.authors = ["Tom Preston-Werner"]
+    gem.files.include(["ext"])
+    gem.extensions << 'ext/extconf.rb'
+    gem.add_dependency('erlectricity', '>= 1.0.1')
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+# require 'rake/rdoctask'
+# Rake::RDocTask.new do |rdoc|
+#   if File.exist?('VERSION.yml')
+#     config = YAML.load(File.read('VERSION.yml'))
+#     version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+#   else
+#     version = ""
+#   end
+# 
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = "ernie #{version}"
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+task :ebuild do
+  ERLC_TEST_FLAGS = ""
+  ERLC_FLAGS = "-o ../ebin"
+  cd "elib"
+  sh "erlc  #{ERLC_FLAGS} #{ERLC_TEST_FLAGS} #{Dir["**/*.erl"].join(" ")}"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 0
+:major: 0

data/bin/ernie

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), *%w[.. lib]))
+ERNIE_ROOT = File.join(File.dirname(__FILE__), *%w[..])
+
+DEFAULT_ERLANG_CODEPATHS = %w[ebin]
+
+def rel(path)
+  File.join(ERNIE_ROOT, path)
+end
+
+def code_paths
+  DEFAULT_ERLANG_CODEPATHS.map {|n| "-pz #{rel(n)}" }.join(" ") + " \\"
+end
+
+require 'optparse'
+require 'pp'
+
+help = <<HELP
+Ernie is an Erlang/Ruby BERT-RPC Server.
+
+Basic Command Line Usage:
+  ernie [options] <path to handler file>
+
+Options:
+HELP
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = help
+
+  opts.on("-p PORT", "--port PORT", "Port") do |x|
+    options[:port] = x
+  end
+
+  opts.on("-d", "--detached", "Run as a daemon") do
+    options[:detached] = true
+  end
+
+  opts.on("-P", "--pidfile PIDFILE", "Location to write pid file.") do |x|
+    options[:pidfile] = x
+  end
+end.parse!
+
+handler = ARGV[0]
+
+unless handler
+  puts "A handler must be specified: ernie /path/to/handler.rb"
+  exit(1)
+end
+
+port = options[:port] || 8000
+pidfile = options[:pidfile] ? "-ernie_server_app pidfile \"'#{options[:pidfile]}'\"" : ''
+detached = options[:detached] ? '-detached' : ''
+
+cmd = %Q{erl -boot start_sasl \
+             #{detached} \
+             +Bc \
+             +K true \
+             -smp enable \
+             #{code_paths}
+             #{pidfile} \
+             -ernie_server_app port #{port} \
+             -ernie_server_app handler '"#{handler}"' \
+             -run ernie_server_app boot}.squeeze(' ')
+puts cmd
+exec(cmd)

data/ebin/ernie_server_app.app

@@ -0,0 +1,2 @@
+{application, ernie_server_app,
+  [{mod, {ernie_server_app, []}}]}.

data/elib/ernie_server.erl

@@ -0,0 +1,104 @@
+-module(ernie_server).
+-behaviour(gen_server).
+
+%% api
+-export([start_link/1, start/1]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+-record(state, {lsock = undefined,
+                ducky = undefined}).
+
+%%====================================================================
+%% API
+%%====================================================================
+
+start_link(Args) ->
+  gen_server:start_link({global, ?MODULE}, ?MODULE, Args, []).
+
+start(Args) ->
+  gen_server:start({global, ?MODULE}, ?MODULE, Args, []).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init([Port, Handler]) ->
+  process_flag(trap_exit, true),
+  error_logger:info_msg("~p starting~n", [?MODULE]),
+  Ducky = port_wrapper:wrap("ruby " ++ Handler),
+  {ok, LSock} = try_listen(Port, 500),
+  spawn(fun() -> loop(LSock, Ducky) end),
+  {ok, #state{lsock = LSock, ducky = Ducky}}.
+
+%%--------------------------------------------------------------------
+%% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
+%%                                      {reply, Reply, State, Timeout} |
+%%                                      {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, Reply, State} |
+%%                                      {stop, Reason, State}
+%% Description: Handling call messages
+%%--------------------------------------------------------------------
+handle_call(_Request, _From, State) ->
+  {reply, ok, State}.
+
+%%--------------------------------------------------------------------
+%% Function: handle_cast(Msg, State) -> {noreply, State} |
+%%                                      {noreply, State, Timeout} |
+%%                                      {stop, Reason, State}
+%% Description: Handling cast messages
+%%--------------------------------------------------------------------
+handle_cast(_Msg, State) -> {noreply, State}.
+
+handle_info(Msg, State) ->
+  error_logger:error_msg("Unexpected message: ~p~n", [Msg]),
+  {noreply, State}.
+
+terminate(_Reason, _State) -> ok.
+code_change(_OldVersion, State, _Extra) -> {ok, State}.
+
+%%====================================================================
+%% Internal
+%%====================================================================
+
+try_listen(Port, 0) ->
+  error_logger:error_msg("Could not listen on port ~p~n", [Port]),
+  {error, "Could not listen on port"};
+try_listen(Port, Times) ->
+  Res = gen_tcp:listen(Port, [binary, {packet, 4}, {active, false}]),
+  case Res of
+    {ok, LSock} ->
+      error_logger:info_msg("Listening on port ~p~n", [Port]),
+      {ok, LSock};
+    {error, Reason} ->
+      error_logger:info_msg("Could not listen on port ~p: ~p~n", [Port, Reason]),
+      timer:sleep(5000),
+      try_listen(Port, Times - 1)
+  end.
+
+loop(LSock, Ducky) ->
+  {ok, Sock} = gen_tcp:accept(LSock),
+  spawn(fun() -> handle_method(Sock, Ducky) end),
+  loop(LSock, Ducky).
+
+handle_method(Sock, Ducky) ->
+  case gen_tcp:recv(Sock, 0) of
+    {ok, BinaryTerm} ->
+      % error_logger:info_msg("From Internet: ~p~n", [BinaryTerm]),
+      {ok, Data} = port_wrapper:rpc(Ducky, BinaryTerm),
+      % error_logger:info_msg("From Port: ~p~n", [Data]),
+      gen_tcp:send(Sock, Data),
+      ok = gen_tcp:close(Sock);
+    {error, closed} ->
+      ok = gen_tcp:close(Sock)
+  end.

data/elib/ernie_server_app.erl

@@ -0,0 +1,13 @@
+-module(ernie_server_app).
+-behaviour(application).
+
+-export([boot/0, start/2, stop/1]).
+
+boot() ->
+  application:start(ernie_server_app).
+
+start(_Type, _Args) ->
+  ernie_server_sup:start_link().
+
+stop(_State) ->
+  ok.

data/elib/ernie_server_sup.erl

@@ -0,0 +1,21 @@
+-module(ernie_server_sup).
+-behaviour(supervisor).
+-export([start_link/0, init/1]).
+
+start_link() ->
+  supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+  {ok, Port} = application:get_env(ernie_server_app, port),
+  io:format("Using port ~p~n", [Port]),
+  {ok, Handler} = application:get_env(ernie_server_app, handler),
+  io:format("Using handler ~p~n", [Handler]),
+  case application:get_env(ernie_server_app, pidfile) of
+    {ok, Location} ->
+      Pid = os:getpid(),
+      ok = file:write_file(Location, list_to_binary(Pid));
+    undefined -> ok
+  end,
+  {ok, {{one_for_one, 1, 60},
+    [{ernie_server, {ernie_server, start_link, [[Port, Handler]]},
+    permanent, brutal_kill, worker, [ernie_server]}]}}.

data/elib/port_wrapper.erl

@@ -0,0 +1,63 @@
+-module(port_wrapper).
+-export([wrap/1, wrap/2, wrap_link/1, wrap_link/2, send/2, shutdown/1, rpc/2]).
+
+wrap(Command) ->
+ spawn(fun() -> process_flag(trap_exit, true), Port = create_port(Command), loop(Port, infinity, Command) end).
+wrap(Command, Timeout) ->
+  spawn(fun() -> process_flag(trap_exit, true), Port = create_port(Command), loop(Port, Timeout, Command) end).
+
+wrap_link(Command) ->
+ spawn_link(fun() -> process_flag(trap_exit, true), Port = create_port(Command), link(Port), loop(Port, infinity, Command) end).
+wrap_link(Command, Timeout) ->
+  spawn_link(fun() -> process_flag(trap_exit, true), Port = create_port(Command), link(Port), loop(Port, Timeout, Command) end).
+
+rpc(WrappedPort, Message) ->
+  send(WrappedPort, Message),
+  receive
+    {WrappedPort, Result} -> {ok, Result}
+  after 15000 ->
+    {error, timed_out, WrappedPort}
+  end.
+
+send(WrappedPort, Message) ->
+  WrappedPort ! {self(), {command, Message}},
+  WrappedPort.
+
+shutdown(WrappedPort) ->
+  WrappedPort ! shutdown,
+  true.
+
+create_port(Command) ->
+  open_port({spawn, Command}, [{packet, 4}, nouse_stdio, exit_status, binary]).
+
+loop(Port, Timeout, Command) ->
+  receive
+    noose ->
+      port_close(Port),
+      noose;
+    shutdown ->
+      port_close(Port),
+      exit(shutdown);
+    {Source, {command, Message}} ->
+      Port ! {self(), {command, Message}},
+      receive
+        {Port, {data, Result}} ->
+          Source ! {self(), Result}
+      after Timeout ->
+        error_logger:error_msg("Port Wrapper ~p timed out in mid operation (~p)!~n", [self(),Message]),
+        % We timed out, which means we need to close and then restart the port
+        port_close(Port), % Should SIGPIPE the child.
+        exit(timed_out)
+      end,
+      loop(Port,Timeout,Command);
+    {Port, {exit_status, _Code}} ->
+      % Hard and Unanticipated Crash
+      error_logger:error_msg( "Port closed! ~p~n", [Port] ),
+      exit({error, _Code});
+    {'EXIT',_Pid,shutdown} ->
+      port_close(Port),
+      exit(shutdown);
+    Any ->
+      error_logger:warning_msg("PortWrapper ~p got unexpected message: ~p~n", [self(), Any]),
+      loop(Port, Timeout, Command)
+  end.

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,126 @@
+require 'rubygems'
+require 'erlectricity'
+require 'logger'
+
+class Ernie
+  class << self
+    attr_accessor :mods, :current_mod, :logger
+  end
+
+  self.mods = {}
+  self.current_mod = nil
+  self.logger = nil
+
+  def self.mod(name, block)
+    m = Mod.new(name)
+    self.current_mod = m
+    self.mods[name] = m
+    block.call
+  end
+
+  def self.fun(name, block)
+    self.current_mod.fun(name, block)
+  end
+
+  def self.logfile(file)
+    self.logger = Logger.new(file)
+  end
+
+  def self.log(text)
+    self.logger.info(text) if self.logger
+  end
+
+  def self.convert(item)
+    if item.instance_of?(Hash)
+      a = [:dict]
+      item.each_pair { |k, v| a << [convert(k), convert(v)] }
+      a
+    elsif item.instance_of?(Array)
+      item.map { |x| convert(x) }
+    else
+      item
+    end
+  end
+
+  def self.deconvert(item)
+    if item.instance_of?(Array)
+      if item.first == :dict
+        item[1..-1].inject({}) do |acc, x|
+          acc[deconvert(x[0])] = deconvert(x[1]); acc
+        end
+      else
+        item.map { |x| deconvert(x) }
+      end
+    else
+      item
+    end
+  end
+
+  def self.dispatch(mod, fun, args)
+    xargs = deconvert(args)
+    self.log("-- " + [mod, fun, xargs].inspect)
+    res = self.mods[mod].funs[fun].call(*xargs)
+    convert(res)
+  end
+
+  def self.start
+    self.log("Starting")
+    self.log(self.mods.inspect)
+    receive do |f|
+      f.when([:call, Symbol, Symbol, Array]) do |mod, fun, args|
+        self.log("-> " + [:call, mod, fun, args].inspect)
+        begin
+          res = self.dispatch(mod, fun, args)
+          xres = [:reply, res]
+          self.log("<- " + xres.inspect)
+          f.send!(xres)
+        rescue Object => e
+          xres = [:error, [:user, 0, e.message]]
+          self.log("<- " + xres.inspect)
+          self.log(e.backtrace.join("\n"))
+          f.send!(xres)
+        end
+        f.receive_loop
+      end
+
+      f.when(Any) do |any|
+        self.log("-> " + any.inspect)
+        xres = [:error, [:server, 0, "Invalid request: #{any.inspect}"]]
+        self.log("<- " + xres.inspect)
+        f.send!(xres)
+        f.receive_loop
+      end
+    end
+  end
+end
+
+class Ernie::Mod
+  attr_accessor :name, :funs
+
+  def initialize(name)
+    self.name = name
+    self.funs = {}
+  end
+
+  def fun(name, block)
+    self.funs[name] = block
+  end
+end
+
+# Root level calls
+
+def mod(name, &block)
+  Ernie.mod(name, block)
+end
+
+def fun(name, &block)
+  Ernie.fun(name, block)
+end
+
+def logfile(name)
+  Ernie.logfile(name)
+end
+
+at_exit do
+  Ernie.start unless $test
+end

data/test/ernie_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class ErnieTest < Test::Unit::TestCase
+  context "mod" do
+    should "add a mod to the mods hash" do
+      mod(:foo) { }
+      assert Ernie.mods[:foo]
+      assert Ernie.mods[:foo].instance_of?(Ernie::Mod)
+    end
+  end
+
+  context "fun" do
+    should "add a fun to the funs hash of the mod" do
+      mod(:foo) { fun(:bar) { } }
+      assert Ernie.mods[:foo].funs[:bar]
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ernie'
+
+class Test::Unit::TestCase
+end
+
+$test = true

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: mojombo-ernie
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tom Preston-Werner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-18 00:00:00 -07:00
+default_executable: ernie
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: erlectricity
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+    version: 
+description: 
+email: tom@mojombo.com
+executables: 
+- ernie
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION.yml
+- bin/ernie
+- ebin/ernie_server_app.app
+- elib/ernie_server.erl
+- elib/ernie_server_app.erl
+- elib/ernie_server_sup.erl
+- elib/port_wrapper.erl
+- ext/Makefile
+- ext/extconf.rb
+- lib/ernie.rb
+- test/ernie_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/mojombo/ernie
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: 
+- test/ernie_test.rb
+- test/test_helper.rb