capricorn 0.2.25 → 2.0.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Simon Menke
+
+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 @@
+# Capricorn

data/bin/capricorn-app-scaffolder

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'capricorn'
+
+def convert_app(app)
+  application = {}
+  application[:id]          = app[1]
+  application[:node]        = app[2]
+  application[:name]        = app[3]
+  application[:domain]      = app[4].shift
+  application[:aliases]     = app[4]
+  application[:environment] = app[5]
+  application
+end
+
+Erlang do |cmd|
+  case cmd.shift
+  when :create
+    recipe = cmd.shift
+    app = convert_app(cmd.first)
+
+    recipe_path = File.expand_path("../../lib/capricorn/recipes/#{recipe}.rb", __FILE__)
+    ctx = Capricorn::SystemContext.run(recipe_path, :application => app)
+
+    send t[true, t[ctx.www_user, ctx.www_group, ctx.root_path]]
+  end
+end

data/bin/capricorn-gem-spec

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'capricorn'
+require 'rubygems/format'
+
+Erlang do |path|
+
+  unless File.extname(path) == ".gem" and File.file?(path)
+    error :not_found
+  end
+
+  begin
+    format = Gem::Format.from_file_by_path(path)
+  rescue Exception => e
+    error :gem_error, e.message
+  end
+
+  spec = format.spec
+  unless spec
+    error :gem_error, "Invalid gem"
+  end
+
+  dependencies = spec.runtime_dependencies.collect do |dep|
+    version_requirements = dep.version_requirements.as_list.collect do |req|
+      op, version = *req.split(/\s+/, 2)
+      BERT::Tuple[op, version]
+    end
+    BERT::Tuple[dep.name, version_requirements]
+  end
+
+  send BERT::Tuple[spec.name, spec.version.to_s, dependencies]
+
+end

data/bin/capricornctl

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require File.dirname(File.expand_path(__FILE__))+'/../../minigems'
+
+begin
+  require 'capricorn-client'
+rescue LoadError
+  $:.unshift(File.dirname(__FILE__)+'/../lib')
+  require 'capricorn-client'
+end
+
+Capricorn::Runner.start

data/bin/capricornd

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path('../../', $0)
+src  = File.expand_path('../../', __FILE__)
+rel  = File.join(src, 'erlang/rel/capricorn')
+etc  = File.join(root, 'etc/capricorn')
+
+if ARGV.size == 1 and ARGV[0] == "install"
+  require 'fileutils'
+
+  FileUtils.mkdir_p(File.join(root, "etc/capricorn"),
+                    :verbose => true)
+  FileUtils.mkdir_p(File.join(root, "var/run/capricorn-machine"),
+                    :verbose => true)
+  FileUtils.mkdir_p(File.join(root, "var/run/capricorn-cluster"),
+                    :verbose => true)
+  FileUtils.mkdir_p(File.join(root, "var/log/sasl"),
+                    :verbose => true)
+
+  FileUtils.cp(File.join(rel, 'etc/capricorn/app.config'),
+               File.join(etc, 'app.config'),
+               :verbose => true)
+  FileUtils.cp(File.join(rel, 'etc/capricorn/cluster-vm.args'),
+               File.join(etc, 'cluster-vm.args'),
+               :verbose => true)
+  FileUtils.cp(File.join(rel, 'etc/capricorn/machine-vm.args'),
+               File.join(etc, 'machine-vm.args'),
+               :verbose => true)
+else
+  exec(File.join(rel, 'bin/capricornd'), root, *ARGV)
+end

data/erlang/lib/bert/doc/overview.edoc

@@ -0,0 +1,4 @@
+@author Simon Menke <simon.menke@gmail.com>
+@copyright 2010 Simon Menke
+@version {@vsn}
+

data/erlang/lib/bert/ebin/bert.app

@@ -0,0 +1,9 @@
+%% This is the application resource file (.app file) for the bert,
+%% application.
+{application, bert, 
+  [{description, "BERT encoder / decoder"},
+   {vsn, "0.1.0"},
+   {modules, [bert]},
+   {registered,[]},
+   {applications, [kernel, stdlib]}
+]}.

data/erlang/lib/bert/rebar.config

@@ -0,0 +1,3 @@
+{cover_enabled, true}.
+{erl_opts, [debug_info, fail_on_warning, {i, ".."}]}.
+{lib_dirs, [".."]}.

data/erlang/lib/bert/src/bert.erl

@@ -0,0 +1,69 @@
+%%% See http://github.com/mojombo/bert.erl for documentation.
+%%% MIT License - Copyright (c) 2009 Tom Preston-Werner <tom@mojombo.com>
+
+-module(bert).
+-version('1.1.0').
+-author("Tom Preston-Werner").
+
+-export([encode/1, decode/1]).
+
+-ifdef(TEST).
+-include("test/bert_test.erl").
+-endif.
+
+%%---------------------------------------------------------------------------
+%% Public API
+
+-spec encode(term()) -> binary().
+
+encode(Term) ->
+  term_to_binary(encode_term(Term)).
+
+-spec decode(binary()) -> term().
+
+decode(Bin) ->
+  decode_term(binary_to_term(Bin)).
+
+%%---------------------------------------------------------------------------
+%% Encode
+
+-spec encode_term(term()) -> term().
+
+encode_term(Term) ->
+  case Term of
+    [] -> {bert, nil};
+    true -> {bert, true};
+    false -> {bert, false};
+    Dict when is_record(Term, dict, 9) ->
+      {bert, dict, encode_term(dict:to_list(Dict))};
+    List when is_list(Term) ->
+      lists:map((fun encode_term/1), List);
+    Tuple when is_tuple(Term) ->
+      TList = tuple_to_list(Tuple),
+      TList2 = lists:map((fun encode_term/1), TList),
+      list_to_tuple(TList2);
+    _Else -> Term
+  end.
+
+%%---------------------------------------------------------------------------
+%% Decode
+
+-spec decode_term(term()) -> term().
+
+decode_term(Term) ->
+  case Term of
+    {bert, nil} -> [];
+    {bert, true} -> true;
+    {bert, false} -> false;
+    {bert, dict, Dict} ->
+      dict:from_list(decode_term(Dict));
+    {bert, Other} ->
+      {bert, Other};
+    List when is_list(Term) ->
+      lists:map((fun decode_term/1), List);
+    Tuple when is_tuple(Term) ->
+      TList = tuple_to_list(Tuple),
+      TList2 = lists:map((fun decode_term/1), TList),
+      list_to_tuple(TList2);
+    _Else -> Term
+  end.  

data/erlang/lib/bertio/doc/overview.edoc

@@ -0,0 +1,4 @@
+@author Simon Menke <simon.menke@gmail.com>
+@copyright 2010 Simon Menke
+@version {@vsn}
+

data/erlang/lib/bertio/ebin/bertio.app

@@ -0,0 +1,9 @@
+%% This is the application resource file (.app file) for the bertio,
+%% application.
+{application, bertio, 
+  [{description, "BERT Port"},
+   {vsn, "0.1.0"},
+   {modules, [bertio]},
+   {registered,[]},
+   {applications, [kernel, stdlib, bert]}
+]}.

data/erlang/lib/bertio/rebar.config

@@ -0,0 +1,3 @@
+{cover_enabled, true}.
+{erl_opts, [debug_info, fail_on_warning, {i, ".."}]}.
+{lib_dirs, [".."]}.

data/erlang/lib/bertio/src/bertio.erl

@@ -0,0 +1,28 @@
+-module(bertio).
+
+-export([open_port/2, port_close/1]).
+-export([send/2, recv/1, recv/2]).
+
+open_port(PortName, PortOptions) ->
+  erlang:open_port(PortName, [{packet, 4}, nouse_stdio, binary|PortOptions]).
+
+send(Port, BERT) ->
+  BERP = bert:encode(BERT),
+  erlang:port_command(Port, BERP).
+
+recv(Port) ->
+  recv(Port, 1000).
+
+recv(Port, Timeout) ->
+  receive
+  {Port, {data, BERP}} ->
+    {bert, bert:decode(BERP)};
+  {Port, Other} ->
+    {Port, Other}
+  after Timeout ->
+    erlang:error(timeout)
+  end.
+
+port_close(Port) ->
+  send(Port, stop),
+  erlang:port_close(Port).

data/erlang/lib/bertrpc/doc/overview.edoc

@@ -0,0 +1,4 @@
+@author Simon Menke <simon.menke@gmail.com>
+@copyright 2010 Simon Menke
+@version {@vsn}
+

data/erlang/lib/bertrpc/ebin/bertrpc.app

@@ -0,0 +1,12 @@
+%% This is the application resource file (.app file) for the bertrpc,
+%% application.
+{application, bertrpc, 
+  [{description, "BERT-RPC Server"},
+   {vsn, "0.1.0"},
+   {modules, [bertrpc,
+              bertrpc_hello_world,
+              fd_tcp]},
+   {registered,[]},
+   {applications, [kernel, stdlib, bert]}
+]}.
+

data/erlang/lib/bertrpc/include/bertrpc.hrl

@@ -0,0 +1 @@
+

data/erlang/lib/bertrpc/rebar.config

@@ -0,0 +1,5 @@
+{cover_enabled, true}.
+{erl_opts, [debug_info, fail_on_warning, {i, ".."}]}.
+{lib_dirs, [".."]}.
+
+{erl_first_files, ["src/fd_tcp.erl", "src/bertrpc.erl"]}.

data/erlang/lib/bertrpc/src/bertrpc.erl

@@ -0,0 +1,471 @@
+-module(bertrpc).
+-behaviour(fd_tcp).
+
+
+
+-export([call/3, call/4, call/5, call/6, cast/4, cast/5, cast/6, info/2, reply/2, stream/0]).
+
+-export([listen_link/4, listen_link/3, listen/4, listen/3]).
+-export([connect_link/3, connect_link/2, connect/3, connect/2]).
+
+-export([behaviour_info/1]).
+-export([init/1, handle_call/3, handle_cast/2, handle_data/2,
+         handle_info/2, terminate/2, code_change/3]).
+
+
+
+-type client_ref()   :: {pid(), reference()} .
+-type request_info() :: {atom(), [term()]} .
+-type action()       :: {'call' | 'cast', atom(), atom(), [term()]} .
+
+-record(request, {
+  action    :: action(),
+  infos=[]  :: [request_info()],
+  stream    :: 'undefined' | [binary()] | binary(),
+  client    :: client_ref()
+}).
+-type request() :: #request{} .
+
+-record(state, {
+  callback :: 'undefined' | atom(),
+  state    :: term(),
+  
+  req_in   :: 'undefined' | request(),
+  req_out  :: 'undefined' | request(),
+  queue    :: queue()
+}).
+-type state() :: #state{} .
+
+
+-define(SOCK_OPTS, [binary, {packet, 4}]).
+
+
+
+%%% Behaviour API
+behaviour_info(callbacks) ->
+  [{init,1}, {handle_call, 3}, {handle_cast, 2}, {handle_info, 2}, {terminate,2}, {code_change,3}];
+behaviour_info(_) ->
+  undefined.
+
+
+
+%%% Start the server
+listen_link(Name, Callback, Args, Port) ->
+  fd_tcp:listen_link(Name, ?MODULE, {Callback, Args}, Port, ?SOCK_OPTS).
+
+listen_link(Callback, Args, Port) ->
+  fd_tcp:listen_link(?MODULE, {Callback, Args}, Port, ?SOCK_OPTS).
+
+
+listen(Name, Callback, Args, Port) ->
+  fd_tcp:listen(Name, ?MODULE, {Callback, Args}, Port, ?SOCK_OPTS).
+
+listen(Callback, Args, Port) ->
+  fd_tcp:listen(?MODULE, {Callback, Args}, Port, ?SOCK_OPTS).
+
+
+
+%%% Start the client
+connect_link(Name, Host, Port) ->
+  fd_tcp:connect_link(Name, ?MODULE, {}, Host, Port, ?SOCK_OPTS).
+
+connect_link(Host, Port) ->
+  fd_tcp:connect_link(?MODULE, {}, Host, Port, ?SOCK_OPTS).
+
+
+connect(Name, Host, Port) ->
+  fd_tcp:connect(Name, ?MODULE, {}, Host, Port, ?SOCK_OPTS).
+
+connect(Host, Port) ->
+  fd_tcp:connect(?MODULE, {}, Host, Port, ?SOCK_OPTS).
+
+
+
+%%% External Process API
+call(Name, Module, Function, Arguments) ->
+  call(Name, Module, Function, Arguments, []).
+
+call(Name, Module, Function, Arguments, Infos) ->
+  call(Name, Module, Function, Arguments, Infos, undefined).
+
+call(Name, Module, Function, Arguments, Infos, Stream) ->
+  fd_tcp:call(Name, #request{
+    action = {call, Module, Function, Arguments},
+    infos  = Infos,
+    stream = Stream
+  }).
+
+
+cast(Name, Module, Function, Arguments) ->
+  cast(Name, Module, Function, Arguments, []).
+
+cast(Name, Module, Function, Arguments, Infos) ->
+  cast(Name, Module, Function, Arguments, Infos, undefined).
+
+cast(Name, Module, Function, Arguments, Infos, Stream) ->
+  fd_tcp:call(Name, #request{
+    action = {cast, Module, Function, Arguments},
+    infos  = Infos,
+    stream = Stream
+  }).
+
+
+reply(wire, {error, Reason}) ->
+  send_chunks(bert:encode({error, Reason}));
+
+reply(wire, Response) ->
+  send_chunks(bert:encode({reply, Response}));
+
+reply(Client, Response) ->
+  fd_tcp:reply(Client, Response).
+
+
+
+%%% Internal Process API
+-spec info(atom(), [term()]) -> ok .
+info(Command, Options) ->
+  send_chunks(bert:encode({info, Command, Options})).
+
+
+-spec call(atom(), atom(), [term()]) -> term() | {error, term()} .
+call(Module, Function, Arguments) ->
+  send_chunks(bert:encode({call, Module, Function, Arguments})).
+
+
+-spec cast(atom(), atom(), [term()]) -> ok .
+cast(Module, Function, Arguments) ->
+  send_chunks(bert:encode({cast, Module, Function, Arguments})).
+
+
+-spec stream() -> {ok, binary() | eof} | {error, term()} .
+stream() ->
+  case fd_tcp:recv(0) of
+  {error, Reason} -> {error, Reason};
+  {ok, <<"">>}    -> {ok, eof};
+  {ok, Packet}    -> {ok, Packet}
+  end.
+
+
+-spec stream([binary()] | binary() | undefined) -> ok .
+stream(undefined) ->
+  ok;
+
+stream(Chunks) ->
+  send_chunks(Chunks),
+  send_chunks(eof).
+
+
+-spec send_chunks([binary()] | binary() | eof | undefined) -> ok .
+send_chunks(Chunk) when is_binary(Chunk) ->
+  fd_tcp:send(Chunk);
+
+send_chunks(eof) ->
+  send_chunks(<<"">>);
+
+send_chunks(undefined) ->
+  ok;
+
+send_chunks(Chunks) when is_list(Chunks) ->
+  [send_chunks(Chunk) || Chunk <- Chunks].
+
+
+
+%%% Initialize the server
+init({Callback, Args}) ->
+  case Callback:init(Args) of
+  {ok, SubState} ->
+    {ok, #state{callback=Callback, state=SubState, queue=queue:new()}};
+  
+  {ok, SubState, hibernate} ->
+    {ok, #state{callback=Callback, state=SubState, queue=queue:new()}, hibernate};
+  
+  {ok, SubState, Timeout} ->
+    {ok, #state{callback=Callback, state=SubState, queue=queue:new()}, Timeout};
+  
+  {stop, Reason} ->
+    {stop, Reason};
+  
+  ignore ->
+    ignore
+  end;
+  
+init({}) ->
+  {ok, #state{queue=queue:new()}}.
+
+
+
+%%% Handle call messages
+-spec handle_call(request(), client_ref(), state()) -> {noreply, state()}.
+handle_call(#request{}=Request, From, #state{}=State) ->
+  {noreply, try_send_request({Request, From}, State)};
+
+handle_call(Request, From, State) ->
+  #state{ callback=Callback, state=CallbackState } = State,
+  Response = Callback:handle_call(Request, From, CallbackState),
+  do_handle_callback_response(Response, State).
+
+
+
+%%% Handle cast messages
+handle_cast(stop, State) ->
+  {stop, normal, State};
+
+handle_cast(Msg, State) ->
+  #state{ callback=Callback, state=CallbackState } = State,
+  Response = Callback:handle_cast(Msg, CallbackState),
+  do_handle_callback_response(Response, State).
+
+
+
+%%% Handle generic messages
+handle_info(Info, State) ->
+  #state{ callback=Callback, state=CallbackState } = State,
+  Response = Callback:handle_info(Info, CallbackState),
+  do_handle_callback_response(Response, State).
+
+
+
+%%% Handle data messages
+handle_data(Data, #state{ req_in=undefined }=State) ->
+  handle_data(Data, State#state{req_in = #request{}});
+
+handle_data(<<"">>, #state{}=State) ->
+  {noreply, State};
+
+handle_data(Data, #state{}=State) ->
+  case bert:decode(Data) of
+  {call, _, _, _} = Action -> 
+    #state { req_in = Request1 } = State,
+    State2 = State#state { req_in = Request1#request { action = Action } },
+    do_handle_request(State2);
+  {cast, _, _, _} = Action -> 
+    #state { req_in = Request1 } = State,
+    State2 = State#state { req_in = Request1#request { action = Action } },
+    do_handle_request(State2);
+  {info, Command, Options} -> 
+    {noreply, do_handle_info(Command, Options, State)};
+  {reply, Result} -> 
+    {noreply, do_handle_reply(Result, State)};
+  {error, Reason} -> 
+    {noreply, do_handle_error(Reason, State)};
+  {noreply} -> 
+    {noreply, do_handle_noreply(State)}
+  end.
+
+
+
+%%% Before stopping the server
+terminate(_Reason, _State) ->
+  ok.
+
+
+
+%%% Code Changes
+code_change(_OldVsn, State, _Extra) ->
+  {ok, State}.
+
+
+
+%%% Internal API
+do_handle_info(Command, Options, #state{}=State) ->
+  #state{ req_in = Request } = State,
+  #request{ infos = Infos } = Request,
+  
+  State#state{
+    req_in = Request#request{ infos = [{Command, Options}|Infos] }
+  }.
+
+
+do_handle_request(State) ->
+  #state{ req_in = Request } = State,
+  #request{ action = Action, infos = Infos } = Request,
+  {Type, Module, Function, Arguments} = Action,
+  
+  #state{ callback = Callback, state = CallbackState } = State,
+  
+  case Type of
+  call ->
+    case Callback:handle_call({Module, Function, Arguments, Infos}, wire, CallbackState) of
+    {reply, {error, Reason}, NewState} ->
+      fd_tcp:send(bert:encode({error, Reason})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {noreply, State2};
+    
+    {reply, Response, NewState} ->
+      fd_tcp:send(bert:encode({reply, Response})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {noreply, State2};
+    
+    {reply, {error, Reason}, NewState, hibernate} ->
+      fd_tcp:send(bert:encode({error, Reason})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {noreply, State2, hibernate};
+    
+    {reply, Response, NewState, hibernate} ->
+      fd_tcp:send(bert:encode({reply, Response})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {noreply, State2, hibernate};
+    
+    {reply, {error, Reason}, NewState, Timeout} ->
+      fd_tcp:send(bert:encode({error, Reason})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {noreply, State2, Timeout};
+    
+    {reply, Response, NewState, Timeout} ->
+      fd_tcp:send(bert:encode({reply, Response})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {noreply, State2, Timeout};
+    
+    {noreply, NewState} ->
+      State2 = State#state{ state = NewState },
+      {noreply, State2};
+    
+    {noreply, NewState, hibernate} ->
+      State2 = State#state{ state = NewState },
+      {noreply, State2, hibernate};
+    
+    {noreply, NewState, Timeout} ->
+      State2 = State#state{ state = NewState },
+      {noreply, State2, Timeout};
+    
+    {stop, Reason, {error, E}, NewState} ->
+      fd_tcp:send(bert:encode({error, E})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {stop, Reason, State2};
+      
+    {stop, Reason, Reply, NewState} ->
+      fd_tcp:send(bert:encode({reply, Reply})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {stop, Reason, State2};
+    
+    {stop, Reason, NewState} ->
+      fd_tcp:send(bert:encode({error, Reason})),
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {stop, Reason, State2}
+    end;
+  cast ->
+    fd_tcp:send(bert:encode({noreply})),
+    
+    case Callback:handle_cast({Module, Function, Arguments, Infos}, CallbackState) of
+    {noreply, NewState} ->
+      State2 = State#state{ state = NewState },
+      {noreply, State2};
+    
+    {noreply, NewState, hibernate} ->
+      State2 = State#state{ state = NewState },
+      {noreply, State2, hibernate};
+    
+    {noreply, NewState, Timeout} ->
+      State2 = State#state{ state = NewState },
+      {noreply, State2, Timeout};
+    
+    {stop, Reason, NewState} ->
+      State2 = State#state{ req_in = undefined, state = NewState },
+      {stop, Reason, State2}
+    end
+  end.
+
+
+do_reset_out_state(State) ->
+  State#state{req_out=undefined}.
+
+
+do_handle_reply(Result, State1) ->
+  #state{ req_out = Request } = State1,
+  #request{ client = Client } = Request,
+  fd_tcp:reply(Client, Result),
+  State2 = do_reset_out_state(State1),
+  try_send_request(queued, State2).
+
+
+do_handle_error(Reason, State1) ->
+  #state{ req_out = Request } = State1,
+  #request{ client = Client } = Request,
+  fd_tcp:reply(Client, {error, Reason}),
+  State2 = do_reset_out_state(State1),
+  try_send_request(queued, State2).
+
+
+do_handle_noreply(State1) ->
+  #state{ req_out = Request } = State1,
+  #request{ client = Client } = Request,
+  fd_tcp:reply(Client, ok),
+  State2 = do_reset_out_state(State1),
+  try_send_request(queued, State2).
+
+
+% send Request from the queue (if there is one)
+try_send_request(queued, #state{req_out=undefined}=State) ->
+  #state{ queue = Queue1 } = State,
+  case queue:out(Queue1) of
+  {{value, Request}, Queue2} ->
+    #request { action = Action, infos = Infos, stream = Stream } = Request,
+    
+    [begin {Command, Options} = Info, info(Command, Options) end || Info <- Infos],
+    case Action of
+    {call, Module, Function, Arguments} ->
+      call(Module, Function, Arguments);
+    {cast, Module, Function, Arguments} ->
+      cast(Module, Function, Arguments)
+    end,
+    stream(Stream),
+    
+    State#state{ queue = Queue2, req_out = Request };
+  {empty, _} ->
+    
+    State
+  end;
+
+% send a request directly
+try_send_request({Request, From}, #state{req_out=undefined}=State) ->
+  #request { action = Action, infos = Infos, stream = Stream } = Request,
+  
+  [begin {Command, Options} = Info, info(Command, Options) end || Info <- Infos],
+  case Action of
+  {call, Module, Function, Arguments} ->
+    call(Module, Function, Arguments);
+  {cast, Module, Function, Arguments} ->
+    cast(Module, Function, Arguments)
+  end,
+  stream(Stream),
+  
+  State#state{
+    req_out = Request#request{ client = From }
+  };
+
+% put a request on the queue
+try_send_request({Request, From}, #state{}=State) ->
+  #state{ queue = Queue1 } = State,
+  
+  Request2 = Request#request{ client = From },
+  Queue2   = queue:in(Request2, Queue1),
+  
+  State#state{ queue = Queue2 }.
+
+
+do_handle_callback_response(Response, #state{}=State) ->
+  case Response of
+  {reply, Reply, NewCallbackState} ->
+    {reply, Reply, State#state{ state=NewCallbackState }};
+  
+  {reply, Reply, NewCallbackState, hibernate} ->
+    {reply, Reply, State#state{ state=NewCallbackState }, hibernate};
+  
+  {reply, Reply, NewCallbackState, Timeout} ->
+    {reply, Reply, State#state{ state=NewCallbackState }, Timeout};
+  
+  {noreply, NewCallbackState} ->
+    {noreply, State#state{ state=NewCallbackState }};
+  
+  {noreply, NewCallbackState, hibernate} ->
+    {noreply, State#state{ state=NewCallbackState }, hibernate};
+  
+  {noreply, NewCallbackState, Timeout} ->
+    {noreply, State#state{ state=NewCallbackState }, Timeout};
+  
+  {stop, Reason, Reply, NewCallbackState} ->
+    {stop, Reason, Reply, State#state{ state=NewCallbackState }};
+  
+  {stop, Reason, NewCallbackState} ->
+    {stop, Reason, State#state{ state=NewCallbackState }}
+  end.