fuzed 0.1.0

data/bin/fuzed-conf

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+puts("You must specify the absolute path to your Rails root as the first argument") and exit unless ARGV[0]
+
+rails_public_dir = File.join(ARGV[0], 'public')
+
+SUBSTITUTIONS = 
+  {:rails_public_dir => rails_public_dir,
+   :port             => ARGV[1] || "80"}
+
+template = File.join(File.dirname(__FILE__), *%w[.. templates fuzed.conf])
+
+conf = File.open(template).read
+SUBSTITUTIONS.each_pair do |key, data|
+  repl_key = '{{ ' + key.to_s.upcase + ' }}'
+  conf.gsub!(repl_key, data)
+end
+
+File.open('fuzed.conf', 'w') do |f|
+  f.write conf
+end
+
+puts 'successfully wrote fuzed.conf in current directory'

data/elibs/port_wrapper.erl

@@ -0,0 +1,55 @@
+-module(port_wrapper).
+-export([wrap/1, send/2, send_from/3, shutdown/1, rpc/2]).
+-author('Dave Fayram').
+
+wrap(Command) ->
+ spawn(fun() -> process_flag(trap_exit, true), Port = create_port(Command), link(Port), loop(Port, [
+]) end).
+  
+rpc(WrappedPort, Message) -> 
+  send(WrappedPort, Message),
+  receive
+    {WrappedPort, Result} -> Result
+  after 10000 -> 
+    {WrappedPort, timed_out}
+  end.
+  
+send(WrappedPort, Message) ->
+  WrappedPort ! {self(), {command, term_to_binary(Message)}},
+  WrappedPort.
+
+send_from(Target, WrappedPort, Message) -> 
+  WrappedPort ! {Target, {command, term_to_binary(Message)}},
+  WrappedPort.
+
+  
+shutdown(WrappedPort) -> 
+  WrappedPort ! shutdown,
+  true.
+
+create_port(Command) ->
+  open_port({spawn, Command}, [{packet, 4}, nouse_stdio, exit_status, binary]).
+
+loop(Port, Monitors) ->
+  receive
+    shutdown ->
+      port_close(Port),
+      exit(shutdown);
+    {Source, {command, Message}} -> 
+      Port ! {self(), {command, Message}},
+      receive
+        {Port, {data, Result}} ->
+          Source ! {self(), binary_to_term(Result)}
+      end,
+      loop(Port,Monitors);
+      
+    {monitor, Proc} when is_pid(Proc) ->
+      loop(Port, [Proc|Monitors]);
+      
+    {Port, {exit_status, _Code}} ->
+      %port_close(Port)
+      exit(external_failure);
+    Any -> 
+      io:format("----------~nWrapper got: ~p~n----------~n", [Any]),
+      loop(Port, Monitors)
+  end.

data/elibs/rails_connection_pool.erl

@@ -0,0 +1,147 @@
+-module(rails_connection_pool). 
+-compile(export_all).
+
+
+%% Convenience Function
+simple_handle_request(Arg,ServerInfo) ->
+  {Source, Resource} = rails_connection_pool:get(),
+  Response = rails_forwarder:handle_request(Resource, Arg, ServerInfo, 10000),
+  rails_connection_pool:refund({Source,Resource}),
+  Response.
+  
+
+handle_request(Arg,ServerInfo) ->
+  handle_request_helper(Arg,ServerInfo,0).
+
+handle_request_helper(_Arg,_ServerInfo,Retries) when Retries > 1 ->
+  throw(timed_out);
+handle_request_helper(Arg,ServerInfo,Retries) ->
+  Remote = fun(A,S,Target) ->
+    {Source, Handler} = rails_connection_pool:get(),
+    Response = rails_forwarder:rails_handle_request(Handler, A, S, 10000),
+    Target ! {rails_response, Response},
+    rails_connection_pool:refund({Source, Handler}) end,
+  _RequestProc = spawn(Remote(Arg,ServerInfo,self())),
+  receive
+    {rails_response, Response} ->
+      Response
+  after 5000 ->
+    handle_request_helper(Arg,ServerInfo, Retries+1)
+  end.
+  
+
+%% Server manipulation
+start() -> 
+  global:register_name(?MODULE, spawn(
+    fun() -> 
+      process_flag(trap_exit, true),
+      rails_connection_pool:loop([],[]) end
+    )
+  ).
+
+add({Node, Proc}) when is_pid(Proc) ->
+  global:send(?MODULE, {add, {Node, Proc}}),
+  ok.
+
+remove(Rsrc) ->
+  global:send(?MODULE, {remove, Rsrc}),
+  ok.
+
+get() ->
+  global:send(?MODULE, {get, self()}),
+  receive
+    {node, X} -> 
+      X
+  end.
+
+refund(Node) ->
+  global:send(?MODULE, {refund, Node}),
+  ok.
+
+list() ->
+  global:send(?MODULE, {list, self()}),
+  receive
+    {nodes, A} ->
+      A
+  end.
+
+list_all() ->
+  global:send(?MODULE, {list_all, self()}),
+  receive
+    {all_nodes, A} ->
+      A
+  end.
+
+remove_server(Server) ->
+  global:send(?MODULE, {remove_server, Server}),
+  ok.
+
+remove_all() ->
+  global:send(?MODULE, {remove_all}),
+  ok.
+
+remove_server_filter(Server, {Server, _X}) -> false;
+remove_server_filter(_Server, {_NotServer, _X}) -> true.
+
+loop([],A) ->
+  receive
+    {add, {Node, Proc}} when is_pid(Proc) ->
+      erlang:link(Proc),
+      loop([{Node,Proc}],[{Node,Proc}|A]);
+    {list, Pid} ->
+      Pid ! {nodes, []},
+      loop([],A);
+    {list_all, Pid} ->
+      Pid ! {all_nodes, A},
+      loop([],A);
+    {refund,Node} ->
+      Membership = lists:member(Node,A),
+      if 
+        Membership ->
+          loop([Node],A);
+        true ->
+          loop([],A)
+      end;
+    {'EXIT', Pid, _Reason} -> 
+      FilterFun = fun({_Node,MPid}) -> MPid /= Pid end,
+      loop([],lists:filter(FilterFun, A))
+  end;
+loop(X,A) -> 
+  receive 
+    {add, {Node, Proc}} when is_pid(Proc)->
+      erlang:link(Proc),
+      I = {Node, Proc},
+      loop([I|X], [I|A]);
+    {remove, I} -> 
+      loop(lists:delete(I,X), lists:delete(I,A));
+    {remove_server, Server} ->
+      PurgedX = lists:filter(fun(Z) -> remove_server_filter(Server, Z) end, X),
+      PurgedA = lists:filter(fun(Z) -> remove_server_filter(Server, Z) end, A),
+      loop(PurgedX, PurgedA);
+    {remove_all} ->
+      loop([],[]);
+    {list, Pid} ->
+      Pid ! {nodes, X},
+      loop(X,A);
+    {list_all, Pid} ->
+      Pid ! {all_nodes, A},
+      loop(X,A);
+    {get, Pid} ->
+      [Node|Rest] = X,
+      Pid ! {node, Node},
+      loop(Rest,A);
+    {refund,Node} ->
+      Membership = lists:member(Node,A),
+      if 
+        Membership ->
+          loop(X ++ [Node],A);
+        true ->
+          loop(X,A)
+      end;
+    {'EXIT', Pid, _Reason} -> 
+      FilterFun = fun({_Node,MPid}) -> MPid /= Pid end,
+      loop(lists:filter(FilterFun,X),lists:filter(FilterFun, A));
+    Other ->
+      io:format("~p loop(X,A) Received unknown message: ~p~n", [?MODULE, Other]),
+      loop(X,A)
+  end.

data/elibs/rails_forwarder.erl

@@ -0,0 +1,112 @@
+-module(rails_forwarder).
+-compile(export_all).
+-include("../yaws_includes/yaws_api.hrl").
+-include("../yaws_includes/yaws.hrl").
+
+%-export([rails_create_responder/1, rails_create_responders/2, rails_handle_request/3, 
+%         rails_handle_request_for/3, get_rails_response/2, prepare_request/1, decode_result/1]).
+
+%create_responder(Command) ->
+%  port_wrapper:wrap(Command).
+%
+%create_responders(Command, N) ->
+%  create_responders_helper(Command, N, []).
+%  
+%create_responders_helper(_Command, 0, Results) ->
+%  Results;
+%create_responders_helper(Command, N, Results) ->
+%  create_responders_helper(Command, N-1, [create_responder(Command)|Results]).
+
+handle_request(Resource, Request, ServerOptions, Timeout) ->
+  {_Node, Responder} = Resource,
+  handle_request_for(Responder, Request, ServerOptions, self()),
+  try get_rails_response(Responder, Timeout) of
+    Any -> Any
+  catch
+    throw:timed_out -> 
+      io:format("--- Timed out, removing resource and retrying!"),
+      rails_connection_pool:remove(Resource),
+      rails_forwarder:handle_request(rails_connection_pool:get(), Request, ServerOptions, Timeout)
+  end.
+
+handle_request_for(Responder, Request, ServerOptions, Target) ->
+  Data = {request, prepare_request(Request, ServerOptions)},
+  port_wrapper:send_from(Target, Responder, Data).
+  
+  
+get_rails_response(Responder, Timeout) ->
+  receive
+    {Responder, Result} ->
+      decode_result(Result);
+    Any ->
+      io:format("Unexpected message in get_rails_response: ~p~n", [Any])
+  after Timeout ->
+    throw(timed_out)
+  end.
+  
+  
+% Fugly data munging
+prepare_request(Request, ServerOptions) ->
+  Headers = Request#arg.headers,
+  {convert_method(Request), convert_version(Request), convert_querypath(Request), 
+   {querydata, prep(Request#arg.querydata)}, {servername, prep(ServerOptions#sconf.servername)},
+   {headers, convert_headers(Request#arg.headers)},
+   {cookies, list_to_tuple(lists:map(fun(X) -> prep(X) end, Headers#headers.cookie))},
+   {pathinfo, prep(ServerOptions#sconf.docroot)},
+   {postdata, Request#arg.clidata}}. % TODO: prepare request for railsification
+  
+decode_result({response, ResponseData}) ->
+  convert_response(ResponseData).
+
+convert_response(EhtmlTuple) ->
+  {Status, AllHeaders, Html} = EhtmlTuple,
+  {allheaders, HeaderList} = AllHeaders,
+  ProcessedHeaderList = lists:map(fun({header, Name, Value}) -> {header, [binary_to_list(Name) ++ ":", binary_to_list(Value)]} end,
+                                  tuple_to_list(HeaderList)),
+  {html, RawResult} = Html,
+  [Status, {allheaders, ProcessedHeaderList}, {html, binary_to_list(RawResult)}].
+
+prep(A) when is_list(A) -> list_to_binary(A);
+prep(A) -> A.
+
+convert_method(Request) ->
+  R = Request#arg.req,
+  {http_request,Method,{_Type,_Path},_} = R,
+  {method, Method}.
+
+convert_querypath(Request)  ->
+   R = Request#arg.req,
+   {http_request,_Method,{_Type,Path},_} = R,
+   {querypath, prep(Path)}.
+
+convert_version(Request) ->
+  R = Request#arg.req,
+  {http_request,_Method,{_Type,_Path},Version} = R,
+  {http_version, Version}.
+
+convert_req(R) ->
+  {http_request,Method,{_Type,Path},_} = R,
+  {Method, prep(Path)}.
+
+convert_headers(A) ->
+  NormalHeaders = [{connection, prep(A#headers.connection)},
+                   {accept, prep(A#headers.accept)},
+                   {host, prep(A#headers.host)},
+                   {if_modified_since, prep(A#headers.if_modified_since)},
+                   {if_match, prep(A#headers.if_match)},
+                   {if_none_match, prep(A#headers.if_none_match)},
+                   {if_range, prep(A#headers.if_range)},
+                   {if_unmodified_since, prep(A#headers.if_unmodified_since)},
+                   {range, prep(A#headers.range)},
+                   {referer, prep(A#headers.referer)},
+                   {user_agent, prep(A#headers.user_agent)},
+                   {accept_ranges, prep(A#headers.accept_ranges)},
+                   {keep_alive, prep(A#headers.keep_alive)},
+                   {location, prep(A#headers.location)},
+                   {content_length, prep(A#headers.content_length)},
+                   {content_type, prep(A#headers.content_type)},
+                   {content_encoding, prep(A#headers.content_encoding)},
+                   {authorization, prep(A#headers.authorization)},
+                   {transfer_encoding, prep(A#headers.transfer_encoding)}],
+   SpecialHeaders = lists:map(fun({http_header, _Len, Name, _, Value}) -> {prep(Name), prep(Value)} end, A#headers.other),
+   list_to_tuple([{Name, Res} || {Name, Res} <- NormalHeaders, Res /= undefined] ++ SpecialHeaders).

data/elibs/resource_manager.erl

@@ -0,0 +1,108 @@
+%%%-------------------------------------------------------------------
+%%% File    : /Users/dfayram/Projects/concilium/elibs/resource_manager.erl
+%%% Author  : David Fayram
+%%%-------------------------------------------------------------------
+-module(resource_manager).
+-behaviour(gen_server).
+
+%% API exports
+-export([start_link/3, start/3,nodes/0,nodecount/0,change_nodecount/1,cycle/0]).
+
+%% gen_server callback exports
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+%% Erlang records are ugly.
+-record(state, {generator = fun() -> undefined end,
+                terminator = fun(_) -> undefined end,
+                nodecount = 4,
+                nodes = [],
+                term_hook = fun(_) -> undefined end
+               }).
+
+%% External call functions
+
+% Note the local server, one of these should run on every
+% node serving up rails responders.
+start_link(Generator, Terminator, NumNodes) ->
+    gen_server:start_link({local, ?MODULE}, ?MODULE, [Generator, Terminator, NumNodes], []).
+start(Generator, Terminator, NumNodes) ->
+    gen_server:start({local, ?MODULE}, ?MODULE, [Generator, Terminator, NumNodes], []).
+
+nodes() -> gen_server:call(?MODULE, nodes).
+nodecount() -> gen_server:call(?MODULE, nodecount).
+change_nodecount(NewNodecount) -> gen_server:cast(?MODULE, {change_nodecount, NewNodecount}).
+cycle() -> gen_server:cast(?MODULE, cycle).
+
+%% GEN_SERVER callbacks.
+init([Generator, Terminator, NumNodes]) ->
+    process_flag(trap_exit, true),
+    Nodes = spawn_nodes(Generator, NumNodes),
+    {ok, #state{generator = Generator, nodecount = NumNodes, 
+                nodes = Nodes, terminator = Terminator}}.
+
+handle_call(term_hook, _From, State) ->
+  {reply, State#state.term_hook, State};
+handle_call({term_hook, Hook}, _From, State) when is_function(Hook, 1) ->
+  {reply, State#state.term_hook, State#state{term_hook = Hook}};
+handle_call(nodecount,_From,State) -> 
+  {reply, State#state.nodecount, State};
+handle_call(nodes, _From, State) ->
+  {reply, State#state.nodes, State}.
+
+handle_cast(cycle, State) -> 
+  drop_nodes(State#state.terminator, State#state.nodes),
+  {noreply, State#state{nodes=spawn_nodes(State#state.generator, State#state.nodecount)}};
+handle_cast({change_nodecount, NewCount}, S) when is_number(NewCount) -> 
+  Count = S#state.nodecount,
+  if
+    NewCount > Count ->
+      {noreply, 
+        S#state{nodecount = NewCount, 
+                nodes = spawn_nodes(S#state.generator, NewCount - Count) ++ S#state.nodes}};
+    NewCount < Count ->
+      {ToKill, ToKeep} = lists:split(NewCount - Count, S#state.nodes),
+      drop_nodes(S#state.terminator, ToKill),
+      {noreply, S#state{nodecount=NewCount, nodes=ToKeep}};
+    true -> 
+      {noreply, S}
+  end.
+
+handle_info({'EXIT', Pid, _Reason}, S) -> 
+  Term = S#state.terminator,
+  Membership = lists:any(fun(X) -> X =:= Pid end, S#state.nodes), 
+  if
+    Membership -> 
+      Term(Pid),
+      Res = lists:delete(Pid, S#state.nodes),
+      NewNode = spawn_linked_node(S#state.generator),
+      {noreply, S#state{nodes=[NewNode|Res]}};
+    true -> 
+      {noreply, S}
+  end;
+handle_info(Any,S) -> 
+  io:format("Got INFO ~p~n", [Any]),
+  {noreply, S}.
+
+terminate(_Reason, _State) ->
+    ok.
+    
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%% Utility functions
+
+spawn_linked_node(Generator) -> 
+  Node = Generator(),
+  link(Node),
+  Node.
+
+spawn_nodes(Generator,NumNodes) ->
+  spawn_nodes(Generator,NumNodes,[]).
+
+spawn_nodes(_Generator,0,Acc) -> Acc;
+spawn_nodes(Generator,NumNodes,Acc) -> spawn_nodes(Generator,NumNodes - 1, [spawn_linked_node(Generator)|Acc]).
+
+drop_nodes(Terminator, Nodes) -> 
+  Killer = fun(Node) -> unlink(Node), Terminator(Node) end,
+  lists:map(Killer, Nodes).