ernie 0.3.1 → 0.3.2

data/README.md

@@ -13,13 +13,20 @@ 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.
 
+Ernie currently supports the following BERT-RPC features:
+* `call` requests
+* `cast` requests
+
 
 Installation
 ------------
 
-  You must have Erlang installed before installing Ernie.
+You must have Erlang installed before installing Ernie.
+
+From GitHub:
 
-    gem install mojombo-ernie -s http://gems.github.com
+    gem install mojombo-ernie -s http://gems.github.com \
+                              -s http://gemcutter.org
 
 
 Running

data/VERSION.yml

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

data/bin/ernie

@@ -14,14 +14,25 @@ def code_paths
   DEFAULT_ERLANG_CODEPATHS.map {|n| "-pz #{rel(n)}" }.join(" ") + " \\"
 end
 
+def version
+  yml = YAML.load(File.read(File.join(File.dirname(__FILE__), *%w[.. VERSION.yml])))
+  "#{yml[:major]}.#{yml[:minor]}.#{yml[:patch]}"
+end
+
 require 'optparse'
 require 'pp'
+require 'yaml'
 
 help = <<HELP
 Ernie is an Erlang/Ruby BERT-RPC Server.
 
 Basic Command Line Usage:
-  ernie [options] <path to handler file>
+  ernie [command] [options]
+
+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.
 
 Options:
 HELP
@@ -29,6 +40,7 @@ HELP
 options = {}
 OptionParser.new do |opts|
   opts.banner = help
+  opts.version = version
 
   opts.on("-h HANDLER", "--handler HANDLER", "Handler ruby file") do |x|
     options[:handler] = x

data/elib/ernie_server.erl

@@ -11,6 +11,10 @@
 -record(state, {lsock = undefined,
                 pending = queue:new()}).
 
+-record(request, {sock = undefined,
+                  info = undefined,
+                  action = undefined}).
+
 %%====================================================================
 %% API
 %%====================================================================
@@ -64,30 +68,17 @@ handle_call(_Request, _From, 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;
+  Request = #request{sock = Sock},
+  State2 = receive_term(Request, State),
+  {noreply, State2};
 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),
+          {{value, Request}, Pending2} = queue:out(State#state.pending),
           % io:format("d", []),
-          spawn(fun() -> process_now(BinaryTerm, Sock, Asset) end),
+          spawn(fun() -> process_now(Request, Asset) end),
           {noreply, State#state{pending = Pending2}};
         empty ->
           % io:format(".", []),
@@ -135,41 +126,91 @@ process_admin(Sock, reload_handlers, _Args, State) ->
   gen_tcp:send(Sock, term_to_binary({reply, <<"Handlers reloaded.">>})),
   ok = gen_tcp:close(Sock),
   State;
-process_admin(Sock, Fun, _Args, 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) ->
+receive_term(Request, State) ->
+  Sock = Request#request.sock,
+  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} ->
+          process_admin(Sock, Fun, Args, State);
+        {info, _Command, _Args} ->
+          Request2 = Request#request{info = BinaryTerm},
+          receive_term(Request2, State);
+        _Any ->
+          Request2 = Request#request{action = BinaryTerm},
+          process_request(Request2, State)
+      end;
+    {error, closed} ->
+      ok = gen_tcp:close(Sock),
+      State
+  end.
+
+process_request(Request, State) ->
+  ActionTerm = binary_to_term(Request#request.action),
+  case ActionTerm of
+    {cast, _Mod, _Fun, _Args} ->
+      Sock = Request#request.sock,
+      gen_tcp:send(Sock, term_to_binary({noreply})),
+      ok = gen_tcp:close(Sock),
+      logger:debug("Closing cast.~n", []);
+    _Any ->
+      ok
+  end,
   case queue:is_empty(State#state.pending) of
     false ->
-      Pending2 = queue:in({pending, BinaryTerm, Sock}, State#state.pending),
+      Pending2 = queue:in(Request, State#state.pending),
       % io:format("Q", []),
       State#state{pending = Pending2};
     true ->
-      try_process_now(BinaryTerm, Sock, State)
+      try_process_now(Request, State)
   end.
 
-try_process_now(BinaryTerm, Sock, State) ->
+try_process_now(Request, State) ->
   case asset_pool:lease() of
     {ok, Asset} ->
       % io:format("i", []),
-      spawn(fun() -> process_now(BinaryTerm, Sock, Asset) end),
+      spawn(fun() -> process_now(Request, Asset) end),
       State;
     empty ->
       % io:format("q", []),
-      Pending2 = queue:in({pending, BinaryTerm, Sock}, State#state.pending),
+      Pending2 = queue:in(Request, 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).
+process_now(Request, Asset) ->
+  try unsafe_process_now(Request, Asset) of
+    _AnyResponse -> ok
+  catch
+    _AnyError -> ok
+  after
+    asset_pool:return(Asset),
+    ernie_server:asset_freed(),
+    gen_tcp:close(Request#request.sock)
+  end.
+
+unsafe_process_now(Request, Asset) ->
+  BinaryTerm = Request#request.action,
+  Term = binary_to_term(BinaryTerm),
+  case Term of
+    {call, Mod, Fun, Args} ->
+      logger:debug("Calling ~p:~p(~p)~n", [Mod, Fun, Args]),
+      Sock = Request#request.sock,
+      {asset, Port, Token} = Asset,
+      logger:debug("Asset: ~p ~p~n", [Port, Token]),
+      {ok, Data} = port_wrapper:rpc(Port, BinaryTerm),
+      gen_tcp:send(Sock, Data),
+      ok = gen_tcp:close(Sock);
+    {cast, Mod, Fun, Args} ->
+      logger:debug("Casting ~p:~p(~p)~n", [Mod, Fun, Args]),
+      {asset, Port, Token} = Asset,
+      logger:debug("Asset: ~p ~p~n", [Port, Token]),
+      {ok, _Data} = port_wrapper:rpc(Port, BinaryTerm)
+  end.

data/ernie.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ernie}
-  s.version = "0.3.1"
+  s.version = "0.3.2"
 
   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.date = %q{2009-08-20}
   s.default_executable = %q{ernie}
   s.email = %q{tom@mojombo.com}
   s.executables = ["ernie"]

data/lib/ernie.rb

@@ -83,6 +83,17 @@ class Ernie
         f.receive_loop
       end
 
+      f.when([:cast, Symbol, Symbol, Array]) do |mod, fun, args|
+        self.log("-> " + [:cast, mod, fun, args].inspect)
+        begin
+          self.dispatch(mod, fun, args)
+        rescue Object => e
+          # ignore
+        end
+        f.send!([:noreply])
+        f.receive_loop
+      end
+
       f.when(Any) do |any|
         self.log("-> " + any.inspect)
         xres = [:error, [:server, 0, "Invalid request: #{any.inspect}"]]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ernie
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Tom Preston-Werner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-14 00:00:00 -07:00
+date: 2009-08-20 00:00:00 -07:00
 default_executable: ernie
 dependencies: 
 - !ruby/object:Gem::Dependency