ernie 0.3.1

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,105 @@
+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 [command] [options]
+        -h, --handler HANDLER            Handler file
+        -p, --port PORT                  Port
+        -n, --number NUMBER              Number of handler instances
+        -d, --detached                   Run as a daemon
+        -P, --pidfile PIDFILE            Location to write pid file.
+    
+    Commands:
+      <none>                Start an Ernie server.
+      reload-handlers       Gracefully reload all of the the ruby handlers
+                            and use the new code for all subsequent requests.
+    
+    Examples:
+      ernie -d -p 9999 -n 10 -h calc.rb
+        Start the ernie server in the background on port 9999 with ten
+        handlers, using the calc.rb handler file.
+    
+      ernie reload-handlers -p 9999
+        Reload the handlers for the ernie server currently running on
+        port 9999.
+
+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}
+
+
+Using the BERTRPC gem to make calls to Ernie
+--------------------------------------------
+
+You can make BERT-RPC calls from Ruby with the [BERTRPC gem](http://github.com/mojombo/bertrpc):
+
+    require 'bertrpc'
+    
+    svc = BERTRPC::Service.new('localhost', 8000)
+    svc.call.calc.add(1, 2)
+    # => 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,65 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ernie"
+    gem.summary = %Q{Ernie is a BERT-RPC server implementation.}
+    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.add_dependency('bertrpc', '>= 0.2.0')
+
+    # 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 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 3

data/bin/ernie

@@ -0,0 +1,97 @@
+#!/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]
+DEFAULT_PORT = 8000
+
+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("-h HANDLER", "--handler HANDLER", "Handler ruby file") do |x|
+    options[:handler] = x
+  end
+
+  opts.on("-p PORT", "--port PORT", "Port") do |x|
+    options[:port] = x
+  end
+
+  opts.on("-n NUMBER", "--number NUMBER", "Number of handler instances") do |x|
+    options[:number] = x
+  end
+
+  opts.on("-l LOGLEVEL", "--log-level LOGLEVEL", "Log level (0-4)") do |x|
+    options[:log_level] = 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!
+
+if command = ARGV[0]
+  if !%w{reload-handlers}.include?(command)
+    puts "Invlalid command. Valid commands are:"
+    puts "  reload-handlers"
+    exit(1)
+  end
+
+  require 'rubygems'
+  require 'bertrpc'
+  port = options[:port] || DEFAULT_PORT
+  svc = BERTRPC::Service.new('localhost', port)
+  puts svc.call.__admin__.send(command.gsub(/-/, '_'))
+else
+  if !options[:handler]
+    puts "A handler must be specified: ernie -h /path/to/handler.rb"
+    exit(1)
+  end
+
+  handler = options[:handler]
+  port = options[:port] || DEFAULT_PORT
+  number = options[:number] || 1
+  log_level = options[:log_level] || 2
+  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}"' \
+               -ernie_server_app number #{number} \
+               -ernie_server_app log_level #{log_level} \
+               -run ernie_server_app boot}.squeeze(' ')
+  puts cmd
+  exec(cmd)
+end

data/ebin/ernie_server_app.app

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

data/elib/asset_pool.erl

@@ -0,0 +1,137 @@
+-module(asset_pool).
+-behaviour(gen_server).
+
+%% api
+-export([start_link/1, start/1, lease/0, return/1, reload_assets/0]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+-record(state, {assets = undefined,
+                handler = undefined,
+                token = undefined}).
+
+%%====================================================================
+%% API
+%%====================================================================
+
+start_link(Args) ->
+  gen_server:start_link({global, ?MODULE}, ?MODULE, Args, []).
+
+start(Args) ->
+  gen_server:start({global, ?MODULE}, ?MODULE, Args, []).
+
+lease() ->
+  gen_server:call({global, ?MODULE}, {lease}).
+
+return(Asset) ->
+  gen_server:call({global, ?MODULE}, {return, Asset}).
+
+reload_assets() ->
+  gen_server:call({global, ?MODULE}, {reload_assets}).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init([Count, Handler]) ->
+  process_flag(trap_exit, true),
+  error_logger:info_msg("~p starting~n", [?MODULE]),
+  Token = make_ref(),
+  Assets = start_handlers(Count, Handler, Token),
+  {ok, #state{assets = Assets, handler = Handler, token = Token}}.
+
+%%--------------------------------------------------------------------
+%% 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({lease}, _From, State) ->
+  Token = State#state.token,
+  case queue:out(State#state.assets) of
+    {{value, Asset}, Assets2} ->
+      {asset, Port, AssetToken} = Asset,
+      case AssetToken =:= Token of
+        false ->
+          port_wrapper:close(Port),
+          Handler = State#state.handler,
+          NewAsset = create_asset(Handler, Token);
+        true ->
+          NewAsset = Asset
+      end,
+      {reply, {ok, NewAsset}, State#state{assets = Assets2}};
+    {empty, _Assets2} ->
+      {reply, empty, State}
+  end;
+handle_call({return, Asset}, _From, State) ->
+  Token = State#state.token,
+  {asset, Port, AssetToken} = Asset,
+  case AssetToken =:= Token of
+    false ->
+      port_wrapper:close(Port),
+      Handler = State#state.handler,
+      NewAsset = create_asset(Handler, Token);
+    true ->
+      NewAsset = Asset
+  end,
+  Assets2 = queue:in(NewAsset, State#state.assets),
+  {reply, ok, State#state{assets = Assets2}};
+handle_call({reload_assets}, _From, State) ->
+  Token = make_ref(),
+  {reply, ok, State#state{token = Token}};
+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({'EXIT', _Pid, normal}, State) ->
+  {noreply, State};
+handle_info({'EXIT', Pid, Error}, State) ->
+  error_logger:error_msg("Port ~p closed with ~p, restarting port...~n", [Pid, Error]),
+  ValidAssets = queue:filter(fun(Item) -> {asset, A, _T} = Item, A =/= Pid end, State#state.assets),
+  Handler = State#state.handler,
+  Token = State#state.token,
+  NewAsset = create_asset(Handler, Token),
+  Assets = queue:in(NewAsset, ValidAssets),
+  {noreply, State#state{assets = Assets}};
+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
+%%====================================================================
+
+start_handlers(Count, Handler, Token) ->
+  start_handlers(queue:new(), Count, Handler, Token).
+
+start_handlers(Assets, 0, _Handler, _Token) ->
+  Assets;
+start_handlers(Assets, Count, Handler, Token) ->
+  Asset = create_asset(Handler, Token),
+  Assets2 = queue:in(Asset, Assets),
+  start_handlers(Assets2, Count - 1, Handler, Token).
+
+create_asset(Handler, Token) ->
+  {asset, port_wrapper:wrap_link("ruby " ++ Handler), Token}.

data/elib/asset_pool_sup.erl

@@ -0,0 +1,15 @@
+-module(asset_pool_sup).
+-behaviour(supervisor).
+-export([start_link/0, init/1]).
+
+start_link() ->
+  supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+  {ok, Handler} = application:get_env(ernie_server_app, handler),
+  io:format("Using handler ~p~n", [Handler]),
+  {ok, Number} = application:get_env(ernie_server_app, number),
+  io:format("Using ~p handler instances~n", [Number]),
+  {ok, {{one_for_one, 1, 60},
+    [{asset_pool, {asset_pool, start_link, [[Number, Handler]]},
+    permanent, brutal_kill, worker, [asset_pool]}]}}.

data/elib/ernie_server.erl

@@ -0,0 +1,175 @@
+-module(ernie_server).
+-behaviour(gen_server).
+
+%% api
+-export([start_link/1, start/1, process/1, asset_freed/0]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+-record(state, {lsock = undefined,
+                pending = queue:new()}).
+
+%%====================================================================
+%% API
+%%====================================================================
+
+start_link(Args) ->
+  gen_server:start_link({global, ?MODULE}, ?MODULE, Args, []).
+
+start(Args) ->
+  gen_server:start({global, ?MODULE}, ?MODULE, Args, []).
+
+process(Sock) ->
+  gen_server:cast({global, ?MODULE}, {process, Sock}).
+
+asset_freed() ->
+  gen_server:cast({global, ?MODULE}, {asset_freed}).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init([Port]) ->
+  process_flag(trap_exit, true),
+  error_logger:info_msg("~p starting~n", [?MODULE]),
+  {ok, LSock} = try_listen(Port, 500),
+  spawn(fun() -> loop(LSock) end),
+  {ok, #state{lsock = LSock}}.
+
+%%--------------------------------------------------------------------
+%% 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({process, Sock}, State) ->
+  case gen_tcp:recv(Sock, 0) of
+    {ok, BinaryTerm} ->
+      logger:debug("Got binary term: ~p~n", [BinaryTerm]),
+      Term = binary_to_term(BinaryTerm),
+      logger:info("Got term: ~p~n", [Term]),
+      case Term of
+        {call, '__admin__', Fun, Args} ->
+          State2 = process_admin(Sock, Fun, Args, State);
+        Any ->
+          State2 = process_normal(BinaryTerm, Sock, State)
+      end,
+      {noreply, State2};
+    {error, closed} ->
+      ok = gen_tcp:close(Sock),
+      {noreply, State}
+  end;
+handle_cast({asset_freed}, State) ->
+  case queue:is_empty(State#state.pending) of
+    false ->
+      case asset_pool:lease() of
+        {ok, Asset} ->
+          {{value, {pending, BinaryTerm, Sock}}, Pending2} = queue:out(State#state.pending),
+          % io:format("d", []),
+          spawn(fun() -> process_now(BinaryTerm, Sock, Asset) end),
+          {noreply, State#state{pending = Pending2}};
+        empty ->
+          % io:format(".", []),
+          {noreply, State}
+      end;
+    true ->
+      {noreply, State}
+  end;
+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}, {reuseaddr, true}]),
+  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) ->
+  {ok, Sock} = gen_tcp:accept(LSock),
+  logger:debug("Accepted socket: ~p~n", [Sock]),
+  ernie_server:process(Sock),
+  loop(LSock).
+
+process_admin(Sock, reload_handlers, _Args, State) ->
+  asset_pool:reload_assets(),
+  gen_tcp:send(Sock, term_to_binary({reply, <<"Handlers reloaded.">>})),
+  ok = gen_tcp:close(Sock),
+  State;
+process_admin(Sock, Fun, _Args, State) ->
+  gen_tcp:send(Sock, term_to_binary({reply, <<"Admin function not supported.">>})),
+  ok = gen_tcp:close(Sock),
+  State.
+
+process_normal(BinaryTerm, Sock, State) ->
+  case queue:is_empty(State#state.pending) of
+    false ->
+      Pending2 = queue:in({pending, BinaryTerm, Sock}, State#state.pending),
+      % io:format("Q", []),
+      State#state{pending = Pending2};
+    true ->
+      try_process_now(BinaryTerm, Sock, State)
+  end.
+
+try_process_now(BinaryTerm, Sock, State) ->
+  case asset_pool:lease() of
+    {ok, Asset} ->
+      % io:format("i", []),
+      spawn(fun() -> process_now(BinaryTerm, Sock, Asset) end),
+      State;
+    empty ->
+      % io:format("q", []),
+      Pending2 = queue:in({pending, BinaryTerm, Sock}, State#state.pending),
+      State#state{pending = Pending2}
+  end.
+
+process_now(BinaryTerm, Sock, Asset) ->
+  % io:format(".", []),
+  % error_logger:info_msg("From Internet: ~p~n", [BinaryTerm]),
+  {asset, Port, Token} = Asset,
+  logger:debug("Asset: ~p ~p~n", [Port, Token]),
+  {ok, Data} = port_wrapper:rpc(Port, BinaryTerm),
+  % error_logger:info_msg("From Port: ~p~n", [Data]),
+  asset_pool:return(Asset),
+  ernie_server:asset_freed(),
+  gen_tcp:send(Sock, Data),
+  ok = gen_tcp:close(Sock).

data/elib/ernie_server_app.erl

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

data/elib/ernie_server_sup.erl

@@ -0,0 +1,19 @@
+-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]),
+  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]]},
+    permanent, brutal_kill, worker, [ernie_server]}]}}.

data/elib/logger.erl

@@ -0,0 +1,108 @@
+-module(logger).
+-behaviour(gen_server).
+
+%% api
+-export([start_link/1, start/1, set_log_level/1, debug/2, info/2, warn/2, error/2, fatal/2]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+         terminate/2, code_change/3]).
+
+-record(state, {log_level = undefined}).
+
+%%====================================================================
+%% API
+%%====================================================================
+
+start_link(Args) ->
+  gen_server:start_link({global, ?MODULE}, ?MODULE, Args, []).
+
+start(Args) ->
+  gen_server:start({global, ?MODULE}, ?MODULE, Args, []).
+
+set_log_level(Level) ->
+  gen_server:call({global, ?MODULE}, {set_log_level, Level}).
+
+debug(Msg, Args) ->
+  gen_server:cast({global, ?MODULE}, {debug, Msg, Args}).
+
+info(Msg, Args) ->
+  gen_server:cast({global, ?MODULE}, {info, Msg, Args}).
+
+warn(Msg, Args) ->
+  gen_server:cast({global, ?MODULE}, {warn, Msg, Args}).
+
+error(Msg, Args) ->
+  gen_server:cast({global, ?MODULE}, {error, Msg, Args}).
+
+fatal(Msg, Args) ->
+  gen_server:cast({global, ?MODULE}, {fatal, Msg, Args}).
+
+%%====================================================================
+%% gen_server callbacks
+%%====================================================================
+
+%%--------------------------------------------------------------------
+%% Function: init(Args) -> {ok, State} |
+%%                         {ok, State, Timeout} |
+%%                         ignore               |
+%%                         {stop, Reason}
+%% Description: Initiates the server
+%%--------------------------------------------------------------------
+init([LogLevel]) ->
+  error_logger:info_msg("~p starting~n", [?MODULE]),
+  {ok, #state{log_level = LogLevel}}.
+
+%%--------------------------------------------------------------------
+%% 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({set_log_level, Level}, _From, State) ->
+  {reply, ok, State#state{log_level = Level}};
+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({debug, Msg, Args}, State) ->
+  log(State#state.log_level, 4, Msg, Args),
+  {noreply, State};
+handle_cast({info, Msg, Args}, State) ->
+  log(State#state.log_level, 3, Msg, Args),
+  {noreply, State};
+handle_cast({warn, Msg, Args}, State) ->
+  log(State#state.log_level, 2, Msg, Args),
+  {noreply, State};
+handle_cast({error, Msg, Args}, State) ->
+  log(State#state.log_level, 1, Msg, Args),
+  {noreply, State};
+handle_cast({fatal, Msg, Args}, State) ->
+  log(State#state.log_level, 0, Msg, Args),
+  {noreply, State};
+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
+%%====================================================================
+
+log(SystemLogLevel, MessageLogLevel, Message, Args) ->
+  case SystemLogLevel >= MessageLogLevel of
+    false -> ok;
+    true -> io:format(Message, Args)
+  end.

data/elib/logger_sup.erl

@@ -0,0 +1,13 @@
+-module(logger_sup).
+-behaviour(supervisor).
+-export([start_link/0, init/1]).
+
+start_link() ->
+  supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+init([]) ->
+  {ok, LogLevel} = application:get_env(ernie_server_app, log_level),
+  io:format("Using log level ~p~n", [LogLevel]),
+  {ok, {{one_for_one, 1, 60},
+    [{logger, {logger, start_link, [[LogLevel]]},
+    permanent, brutal_kill, worker, [logger]}]}}.

data/elib/port_wrapper.erl

@@ -0,0 +1,67 @@
+-module(port_wrapper).
+-export([wrap/1, wrap/2, wrap_link/1, wrap_link/2, send/2, shutdown/1, close/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.
+
+close(WrappedPort) ->
+  WrappedPort ! noose,
+  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/ernie.gemspec

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ernie}
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tom Preston-Werner"]
+  s.date = %q{2009-08-14}
+  s.default_executable = %q{ernie}
+  s.email = %q{tom@mojombo.com}
+  s.executables = ["ernie"]
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION.yml",
+     "bin/ernie",
+     "ebin/ernie_server_app.app",
+     "elib/asset_pool.erl",
+     "elib/asset_pool_sup.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/calc.rb",
+     "ext/Makefile",
+     "ext/extconf.rb",
+     "lib/ernie.rb",
+     "test/ernie_test.rb",
+     "test/load.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mojombo/ernie}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Ernie is a BERT-RPC server implementation.}
+  s.test_files = [
+    "test/ernie_test.rb",
+     "test/load.rb",
+     "test/test_helper.rb",
+     "examples/calc.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<erlectricity>, [">= 1.0.1"])
+      s.add_runtime_dependency(%q<bertrpc>, [">= 0.2.0"])
+    else
+      s.add_dependency(%q<erlectricity>, [">= 1.0.1"])
+      s.add_dependency(%q<bertrpc>, [">= 0.2.0"])
+    end
+  else
+    s.add_dependency(%q<erlectricity>, [">= 1.0.1"])
+    s.add_dependency(%q<bertrpc>, [">= 0.2.0"])
+  end
+end

data/examples/calc.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ernie'
+
+mod(:calc) do
+  fun(:add) do |a, b|
+    a + b
+  end
+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/load.rb

@@ -0,0 +1,14 @@
+require 'bertrpc'
+
+threads = []
+svc = BERTRPC::Service.new('localhost', 8000)
+
+5.times do
+  threads << Thread.new do
+    i = 0
+    100.times { i += svc.call.calc.add(1, 2) }
+    print "#{i}\n"
+  end
+end
+
+threads.each { |t| t.join }

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,101 @@
+--- !ruby/object:Gem::Specification 
+name: ernie
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+platform: ruby
+authors: 
+- Tom Preston-Werner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-14 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: 
+- !ruby/object:Gem::Dependency 
+  name: bertrpc
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    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/asset_pool.erl
+- elib/asset_pool_sup.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/calc.rb
+- ext/Makefile
+- ext/extconf.rb
+- lib/ernie.rb
+- test/ernie_test.rb
+- test/load.rb
+- test/test_helper.rb
+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 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ernie is a BERT-RPC server implementation.
+test_files: 
+- test/ernie_test.rb
+- test/load.rb
+- test/test_helper.rb
+- examples/calc.rb