runs

:wq

src/et_piece.erl

@@ -1,105 +0,0 @@
--module(et_piece).
--vsn("1.0.4").
--author("Craig Everett <zxq9@zxq9.com>").
--copyright("Craig Everett <zxq9@zxq9.com>").
--license("MIT").
-
--export([rand/0, new/1, flip/2, points/2, points/1, type/1, sides/1]).
-
--export_type([data/0]).
-
--record(p,
-        {flip = 1 :: 1..4,
-         type = i :: erltris:type()}).
-
--opaque data() :: #p{}.
-
-rand() ->
-    case rand:uniform(7) of
-        1 -> new(i);
-        2 -> new(o);
-        3 -> new(t);
-        4 -> new(s);
-        5 -> new(z);
-        6 -> new(j);
-        7 -> new(l)
-    end.
-
-
-new(T) -> #p{type = T}.
-
-
-flip(r, Piece = #p{flip = 4}) -> Piece#p{flip = 1};
-flip(r, Piece = #p{flip = F}) -> Piece#p{flip = F + 1};
-flip(l, Piece = #p{flip = 1}) -> Piece#p{flip = 4};
-flip(l, Piece = #p{flip = F}) -> Piece#p{flip = F - 1}.
-
-
-points(Piece, {LX, LY}) ->
-    Offsets = points(Piece),
-    Translate = fun({OX, OY}) -> {LX + OX, LY + OY} end,
-    lists:map(Translate, Offsets).
-
-
-points(#p{flip = F, type = T}) ->
-    offset(T, F).
-
-offset(i, 1) -> [{0, 2}, {1, 2}, {2, 2}, {3, 2}];
-offset(i, 2) -> [{2, 3}, {2, 2}, {2, 1}, {2, 0}];
-offset(i, 3) -> [{0, 1}, {1, 1}, {2, 1}, {3, 1}];
-offset(i, 4) -> [{1, 3}, {1, 2}, {1, 1}, {1, 0}];
-offset(o, _) -> [{1, 1}, {1, 2}, {2, 1}, {2, 2}];
-offset(t, 1) -> [{0, 1}, {1, 1}, {2, 1}, {1, 2}];
-offset(t, 2) -> [{1, 2}, {1, 1}, {1, 0}, {2, 1}];
-offset(t, 3) -> [{0, 1}, {1, 1}, {2, 1}, {1, 0}];
-offset(t, 4) -> [{1, 2}, {1, 1}, {1, 0}, {0, 1}];
-offset(s, 1) -> [{0, 1}, {1, 1}, {1, 2}, {2, 2}];
-offset(s, 2) -> [{1, 2}, {1, 1}, {2, 1}, {2, 0}];
-offset(s, 3) -> [{0, 0}, {1, 0}, {1, 1}, {2, 1}];
-offset(s, 4) -> [{0, 2}, {0, 1}, {1, 1}, {1, 0}];
-offset(z, 1) -> [{0, 2}, {1, 2}, {1, 1}, {2, 1}];
-offset(z, 2) -> [{1, 0}, {1, 1}, {2, 1}, {2, 2}];
-offset(z, 3) -> [{0, 1}, {1, 1}, {1, 0}, {2, 0}];
-offset(z, 4) -> [{0, 0}, {0, 1}, {1, 1}, {1, 2}];
-offset(j, 1) -> [{0, 2}, {0, 1}, {1, 1}, {2, 1}];
-offset(j, 2) -> [{1, 0}, {1, 1}, {1, 2}, {2, 2}];
-offset(j, 3) -> [{0, 1}, {1, 1}, {2, 1}, {2, 0}];
-offset(j, 4) -> [{0, 0}, {1, 0}, {1, 1}, {1, 2}];
-offset(l, 1) -> [{0, 1}, {1, 1}, {2, 1}, {2, 2}];
-offset(l, 2) -> [{1, 2}, {1, 1}, {1, 0}, {2, 0}];
-offset(l, 3) -> [{0, 0}, {0, 1}, {1, 1}, {2, 1}];
-offset(l, 4) -> [{0, 2}, {1, 2}, {1, 1}, {1, 0}].
-
-
-type(#p{type = T}) -> T.
-
-
-sides(#p{type = T, flip = F}) ->
-    sides(T, F).
-
-
-sides(i, 1) -> {0, 3, 2};
-sides(i, 2) -> {2, 2, 3};
-sides(i, 3) -> {0, 3, 1};
-sides(i, 4) -> {1, 1, 3};
-sides(o, _) -> {1, 2, 2};
-sides(t, 1) -> {0, 2, 2};
-sides(t, 2) -> {1, 2, 2};
-sides(t, 3) -> {0, 2, 1};
-sides(t, 4) -> {0, 1, 2};
-sides(s, 1) -> {0, 2, 2};
-sides(s, 2) -> {1, 2, 2};
-sides(s, 3) -> {0, 2, 1};
-sides(s, 4) -> {0, 1, 2};
-sides(z, 1) -> {0 ,2, 2};
-sides(z, 2) -> {1, 2, 2};
-sides(z, 3) -> {0 ,2, 1};
-sides(z, 4) -> {0, 1, 2};
-sides(j, 1) -> {0, 2, 2};
-sides(j, 2) -> {1, 2, 2};
-sides(j, 3) -> {0, 2, 1};
-sides(j, 4) -> {0, 1, 2};
-sides(l, 1) -> {0, 2, 2};
-sides(l, 2) -> {1, 2, 2};
-sides(l, 3) -> {0, 2, 1};
-sides(l, 4) -> {0, 1, 2}.

src/et_well.erl

@@ -1,79 +0,0 @@
--module(et_well).
--vsn("1.0.4").
--author("Craig Everett <zxq9@zxq9.com>").
--copyright("Craig Everett <zxq9@zxq9.com>").
--license("MIT").
-
--export([new/0, new/2,
-         dimensions/1, height/1, width/1,
-         fetch/3, store/4, complete/1, collapse/2]).
-
--export_type([playfield/0]).
-
-
--opaque playfield() :: tuple().
-
-
-new() ->
-    new(10, 20).
-
-
-new(W, H) ->
-    erlang:make_tuple(H, row(W)).
-
-
-row(W) ->
-    erlang:make_tuple(W, x).
-
-
-dimensions(Well) ->
-    H = size(Well),
-    W = size(element(1, Well)),
-    {W, H}.
-
-
-height(Well) ->
-    size(Well).
-
-
-width(Well) ->
-    size(element(1, Well)).
-
-
-fetch(Well, X, Y) ->
-    element(X, element(Y, Well)).
-
-
-store(Well, Value, X, Y) ->
-    setelement(Y, Well, setelement(X, element(Y, Well), Value)).
-
-
-complete(Well) ->
-    {W, H} = dimensions(Well),
-    complete(H, W, Well, []).
-
-complete(Y, W, Well, Lines) when Y >= 1 ->
-    case line_complete(W, element(Y, Well)) of
-        true  -> complete(Y - 1, W, Well, [Y | Lines]);
-        false -> complete(Y - 1, W, Well, Lines)
-    end;
-complete(_, _, _, Lines) ->
-    Lines.
-
-line_complete(X, Line) when X >= 1 ->
-    case element(X, Line) of
-        x -> false;
-        _ -> line_complete(X - 1, Line)
-    end;
-line_complete(_, _) ->
-    true.
-
-
-collapse(Well, Lines) ->
-    Blank = row(width(Well)),
-    Crunch =
-        fun(L, {W, Count}) ->
-            Crunched = erlang:insert_element(1, erlang:delete_element(L, W), Blank),
-            {Crunched, Count + 1}
-        end,
-    lists:foldl(Crunch, {Well, 0}, Lines).

src/fd_chat.erl

@@ -1,262 +0,0 @@
-% @doc
-% controller for chat
--module(fd_chat).
--vsn("0.1.0").
--behavior(gen_server).
--author("Peter Harpending <peterharpending@qpq.swiss>").
--copyright("Peter Harpending <peterharpending@qpq.swiss>").
--license("BSD-2-Clause-FreeBSD").
-
--export([
-    join/1,
-    relay/1,
-    nick_available/1
-]).
--export([start_link/0]).
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         code_change/3, terminate/2]).
-
--include("$zx_include/zx_logger.hrl").
-
-
--record(o, {pid  :: pid(),
-            nick :: string()}).
--type orator() :: #o{}.
-
--record(s, {orators = [] :: [orator()]}).
-
--type state()   :: #s{}.
-
-
-
-%%% Service Interface
-
--spec join(Nick) -> Result
-    when Nick   :: string(),
-         Result :: ok
-                 | {error, Reason :: any()}.
-
-join(Nick) ->
-    gen_server:call(?MODULE, {join, Nick}).
-
-
-
--spec nick_available(Nick) -> Result
-    when Nick   :: string(),
-         Result :: boolean().
-
-nick_available(Nick) ->
-    gen_server:call(?MODULE, {nick_available, Nick}).
-
-
-
--spec relay(Message) -> ok
-    when Message :: string().
-
-relay(Message) ->
-    gen_server:cast(?MODULE, {relay, self(), Message}).
-
-
-%%% Startup Functions
-
-
--spec start_link() -> Result
-    when Result :: {ok, pid()}
-                 | {error, Reason :: term()}.
-%% @private
-%% This should only ever be called by fd_chat_orators (the service-level supervisor).
-
-start_link() ->
-    gen_server:start_link({local, ?MODULE}, ?MODULE, none, []).
-
-
--spec init(none) -> {ok, state()}.
-%% @private
-%% Called by the supervisor process to give the process a chance to perform any
-%% preparatory work necessary for proper function.
-
-init(none) ->
-    ok = tell("~p Starting.", [?MODULE]),
-    State = #s{},
-    {ok, State}.
-
-
-
-%%% gen_server Message Handling Callbacks
-
-
--spec handle_call(Message, From, State) -> Result
-    when Message  :: term(),
-         From     :: {pid(), reference()},
-         State    :: state(),
-         Result   :: {reply, Response, NewState}
-                   | {noreply, State},
-         Response :: term(),
-         NewState :: state().
-%% @private
-%% The gen_server:handle_call/3 callback.
-%% See: http://erlang.org/doc/man/gen_server.html#Module:handle_call-3
-
-handle_call({join, Nick}, {Pid, _}, State) ->
-    {Reply, NewState} = do_join(Pid, Nick, State),
-    {reply, Reply, NewState};
-handle_call({nick_available, Nick}, _, State = #s{orators = Orators}) ->
-    Reply = is_nick_available(Nick, Orators),
-    {reply, Reply, State};
-handle_call(Unexpected, From, State) ->
-    ok = tell("~p Unexpected call from ~tp: ~tp~n", [?MODULE, From, Unexpected]),
-    {noreply, State}.
-
-
--spec handle_cast(Message, State) -> {noreply, NewState}
-    when Message  :: term(),
-         State    :: state(),
-         NewState :: state().
-%% @private
-%% The gen_server:handle_cast/2 callback.
-%% See: http://erlang.org/doc/man/gen_server.html#Module:handle_cast-2
-
-handle_cast({relay, From, Message}, State = #s{orators = Orators}) ->
-    do_relay(From, Message, Orators),
-    {noreply, State};
-handle_cast(Unexpected, State) ->
-    ok = tell("~p Unexpected cast: ~tp~n", [?MODULE, Unexpected]),
-    {noreply, State}.
-
-
--spec handle_info(Message, State) -> {noreply, NewState}
-    when Message  :: term(),
-         State    :: state(),
-         NewState :: state().
-%% @private
-%% The gen_server:handle_info/2 callback.
-%% See: http://erlang.org/doc/man/gen_server.html#Module:handle_info-2
-
-handle_info(Msg = {'DOWN', _Mon, process, _Pid, _Reason}, State) ->
-    NewState = handle_down(Msg, State),
-    {noreply, NewState};
-handle_info(Unexpected, State) ->
-    ok = tell("~p Unexpected info: ~tp~n", [?MODULE, Unexpected]),
-    {noreply, State}.
-
-
-
-%%% OTP Service Functions
-
--spec code_change(OldVersion, State, Extra) -> Result
-    when OldVersion :: {down, Version} | Version,
-         Version    :: term(),
-         State      :: state(),
-         Extra      :: term(),
-         Result     :: {ok, NewState}
-                     | {error, Reason :: term()},
-         NewState   :: state().
-%% @private
-%% The gen_server:code_change/3 callback.
-%% See: http://erlang.org/doc/man/gen_server.html#Module:code_change-3
-
-code_change(_, State, _) ->
-    {ok, State}.
-
-
--spec terminate(Reason, State) -> no_return()
-    when Reason :: normal
-                 | shutdown
-                 | {shutdown, term()}
-                 | term(),
-         State  :: state().
-%% @private
-%% The gen_server:terminate/2 callback.
-%% See: http://erlang.org/doc/man/gen_server.html#Module:terminate-2
-
-terminate(_, _) ->
-    ok.
-
-
-%%% internals
-
--spec do_join(Pid, Nick, State) -> {Reply, NewState}
-    when Pid      :: pid(),
-         Nick     :: string(),
-         Reply    :: ok | {error, Reason :: any()},
-         NewState :: State.
-
-do_join(Pid, Nick, State = #s{orators = Orators}) ->
-    case ensure_can_join(Pid, Nick, Orators) of
-        ok    -> do_join2(Pid, Nick, State);
-        Error -> {Error, State}
-    end.
-
-
-do_join2(Pid, Nick, State = #s{orators = Orators}) ->
-    _Monitor   = erlang:monitor(process, Pid),
-    NewOrator  = #o{pid = Pid, nick = Nick},
-    NewOrators = [NewOrator | Orators],
-    NewState   = State#s{orators = NewOrators},
-    {ok, NewState}.
-
-
--spec ensure_can_join(Pid, Nick, Orators) -> Result
-    when Pid     :: pid(),
-         Nick    :: string(),
-         Orators :: [orator()],
-         Result  :: ok
-                  | {error, Reason},
-         Reason  :: any().
-% @private
-% ensures both Pid and Nick are unique
-
-ensure_can_join(Pid, _   , [#o{pid  = Pid}  | _   ]) -> {error, already_joined};
-ensure_can_join(_  , Nick, [#o{nick = Nick} | _   ]) -> {error, {nick_taken, Nick}};
-ensure_can_join(Pid, Nick, [_               | Rest]) -> ensure_can_join(Pid, Nick, Rest);
-ensure_can_join(_  , _   , []                      ) -> ok.
-
-
--spec is_nick_available(Nick, Orators) -> boolean()
-    when Nick    :: string(),
-         Orators :: [orator()].
-
-is_nick_available(Nick, [#o{nick = Nick} | _   ]) -> false;
-is_nick_available(Nick, [_               | Rest]) -> is_nick_available(Nick, Rest);
-is_nick_available(_   , []                      ) -> true.
-
-
-
--spec handle_down(Msg, State) -> NewState
-    when Msg      :: {'DOWN', Mon, process, Pid, Reason},
-         Mon      :: erlang:monitor(),
-         Pid      :: pid(),
-         Reason   :: any(),
-         State    :: state(),
-         NewState :: State.
-
-handle_down(Msg = {'DOWN', _, process, Pid, _}, State = #s{orators = Orators}) ->
-    NewOrators = hdn(Msg, Pid, Orators, []),
-    NewState = State#s{orators = NewOrators},
-    NewState.
-
-% encountered item, removing
-hdn(_,   Pid, [#o{pid = Pid} | Rest], Acc) -> Rest ++ Acc;
-hdn(Msg, Pid, [Skip          | Rest], Acc) -> hdn(Msg, Pid, Rest, [Skip | Acc]);
-hdn(Msg, _,   []                    , Acc) ->
-    log("~tp: Unexpected message: ~tp", [?MODULE, Msg]),
-    Acc.
-
-
-do_relay(Pid, Message, Orators) ->
-    case lists:keyfind(Pid, #o.pid, Orators) of
-        #o{nick = Nick} ->
-            do_relay2(Nick, Message, Orators);
-        false ->
-            tell("~tp: Message received from outsider ~tp: ~tp", [?MODULE, Pid, Message]),
-            error
-    end.
-
-% skip
-do_relay2(Nick, Msg, [#o{nick = Nick} | Rest]) ->
-    do_relay2(Nick, Msg, Rest);
-do_relay2(Nick, Msg, [#o{pid = Pid} | Rest]) ->
-    Pid ! {chat, {relay, Nick, Msg}},
-    do_relay2(Nick, Msg, Rest);
-do_relay2(_, _, []) ->
-    ok.

src/fd_httpd.erl

@@ -0,0 +1,39 @@
+-module(fd_httpd).
+-vsn("0.1.0").
+-behaviour(supervisor).
+-author("Peter Harpending <peterharpending@qpq.swiss>").
+-copyright("Peter Harpending <peterharpending@qpq.swiss>").
+-license("BSD-2-Clause-FreeBSD").
+
+-export([start_link/0]).
+-export([init/1]).
+
+
+-spec start_link() -> {ok, pid()}.
+%% @private
+%% This supervisor's own start function.
+
+start_link() ->
+  supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
+
+-spec init([]) -> {ok, {supervisor:sup_flags(), [supervisor:child_spec()]}}.
+%% @private
+%% The OTP init/1 function.
+
+init([]) ->
+    RestartStrategy = {one_for_one, 1, 60},
+    FileCache = {fd_httpd_sfc,
+                 {fd_httpd_sfc, start_link, []},
+                 permanent,
+                 5000,
+                 worker,
+                 [fd_httpd_sfc]},
+    Clients   = {fd_httpd_clients,
+                 {fd_httpd_clients, start_link, []},
+                 permanent,
+                 5000,
+                 supervisor,
+                 [fd_httpd_clients]},
+    Children  = [FileCache, Clients],
+    {ok, {RestartStrategy, Children}}.

src/fd_httpd_client.erl

@@ -13,7 +13,7 @@
 %%% http://erlang.org/doc/design_principles/spec_proc.html
 %%% @end
 
--module(fd_http_client).
+-module(fd_httpd_client).
 -vsn("0.1.0").
 -author("Peter Harpending <peterharpending@qpq.swiss>").
 -copyright("Peter Harpending <peterharpending@qpq.swiss>").
@@ -52,11 +52,11 @@
                        | {shutdown, term()}
                        | term().
 %% @private
-%% How the fd_client_man or a prior fd_client kicks things off.
+%% How the fd_httpd_client_man or a prior fd_httpd_client kicks things off.
-%% This is called in the context of fd_client_man or the prior fd_client.
+%% This is called in the context of fd_httpd_client_man or the prior fd_httpd_client.
 
 start(ListenSocket) ->
-    fd_client_sup:start_acceptor(ListenSocket).
+    fd_httpd_client_sup:start_acceptor(ListenSocket).
 
 
 -spec start_link(ListenSocket) -> Result
@@ -67,7 +67,7 @@ start(ListenSocket) ->
                        | {shutdown, term()}
                        | term().
 %% @private
-%% This is called by the fd_client_sup. While start/1 is called to iniate a startup
+%% This is called by the fd_httpd_client_sup. While start/1 is called to iniate a startup
 %% (essentially requesting a new worker be started by the supervisor), this is
 %% actually called in the context of the supervisor.
 
@@ -86,7 +86,7 @@ start_link(ListenSocket) ->
 %% call to listen/3.
 
 init(Parent, ListenSocket) ->
-    ok = io:format("~p Listening.~n", [self()]),
+    ok = tell("~p Listening.~n", [self()]),
     Debug = sys:debug_options([]),
     ok = proc_lib:init_ack(Parent, {ok, self()}),
     listen(Parent, Debug, ListenSocket).
@@ -98,7 +98,7 @@ init(Parent, ListenSocket) ->
          ListenSocket :: gen_tcp:socket().
 %% @private
 %% This function waits for a TCP connection. The owner of the socket is still
-%% the fd_client_man (so it can still close it on a call to fd_client_man:ignore/0),
+%% the fd_httpd_client_man (so it can still close it on a call to fd_httpd_client_man:ignore/0),
 %% but the only one calling gen_tcp:accept/1 on it is this process. Closing the socket
 %% is one way a manager process can gracefully unblock child workers that are blocking
 %% on a network accept.
@@ -110,12 +110,12 @@ listen(Parent, Debug, ListenSocket) ->
         {ok, Socket} ->
             {ok, _} = start(ListenSocket),
             {ok, Peer} = inet:peername(Socket),
-            ok = io:format("~p Connection accepted from: ~p~n", [self(), Peer]),
+            ok = tell("~p Connection accepted from: ~p~n", [self(), Peer]),
-            ok = fd_client_man:enroll(),
+            ok = fd_httpd_client_man:enroll(),
             State = #s{socket = Socket},
             loop(Parent, Debug, State);
         {error, closed} ->
-            ok = io:format("~p Retiring: Listen socket closed.~n", [self()]),
+            ok = tell("~p Retiring: Listen socket closed.~n", [self()]),
             exit(normal)
      end.
 
@@ -142,17 +142,17 @@ loop(Parent, Debug, State = #s{socket = Socket, next = Next0}) ->
                     %% should trigger bad request
                     tell(error, "~p QHL parse error: ~tp", [?LINE, Error]),
                     tell(error, "~p bad request:~n~ts", [?LINE, Received]),
-                    fd_http_utils:http_err(Socket, 400),
+                    fd_httpd_utils:http_err(Socket, 400),
                     gen_tcp:shutdown(Socket, read_write),
                     exit(normal)
             end;
         {tcp_closed, Socket} ->
-            ok = io:format("~p Socket closed, retiring.~n", [self()]),
+            ok = tell("~p Socket closed, retiring.~n", [self()]),
             exit(normal);
         {system, From, Request} ->
             sys:handle_system_msg(Request, From, Parent, ?MODULE, Debug, State);
         Unexpected ->
-            ok = io:format("~p Unexpected message: ~tp", [self(), Unexpected]),
+            ok = tell("~p Unexpected message: ~tp", [self(), Unexpected]),
             loop(Parent, Debug, State)
     end.
 
@@ -232,7 +232,6 @@ handle_request(Sock, R = #request{method = M, path = P}, Received) when M =/= un
 
 route(Sock, get, Route, Request, Received) ->
     case Route of
-         <<"/ws/tetris">> -> ws_tetris(Sock, Request, Received);
          <<"/ws/echo">>   -> ws_echo(Sock, Request)                 , Received;
          <<"/">>          -> route_static(Sock, <<"/index.html">>)  , Received;
          _                -> route_static(Sock, Route)              , Received
@@ -240,10 +239,10 @@ route(Sock, get, Route, Request, Received) ->
 route(Sock, post, Route, Request, Received) ->
     case Route of
          <<"/wfcin">>       -> wfcin(Sock, Request) , Received;
-         _                  -> fd_http_utils:http_err(Sock, 404)  , Received
+         _                  -> fd_httpd_utils:http_err(Sock, 404)  , Received
     end;
 route(Sock, _, _, _, Received) ->
-    fd_http_utils:http_err(Sock, 404),
+    fd_httpd_utils:http_err(Sock, 404),
     Received.
 
 
@@ -253,13 +252,13 @@ route(Sock, _, _, _, Received) ->
          Route  :: binary().
 
 route_static(Sock, Route) ->
-    respond_static(Sock, fd_sfc:query(Route)).
+    respond_static(Sock, fd_httpd_sfc:query(Route)).
 
 
 
 -spec respond_static(Sock, MaybeEty) -> ok
     when Sock     :: gen_tcp:socket(),
-         MaybeEty :: fd_sfc:maybe_entry().
+         MaybeEty :: fd_httpd_sfc:maybe_entry().
 
 respond_static(Sock, {found, Entry}) ->
     % -record(e, {fs_path       :: file:filename(),
@@ -268,87 +267,18 @@ respond_static(Sock, {found, Entry}) ->
     %             encoding      :: encoding(),
     %             contents      :: binary()}).
     Headers0 =
-        case fd_sfc_entry:encoding(Entry) of
+        case fd_httpd_sfc_entry:encoding(Entry) of
             gzip -> [{"content-encoding", "gzip"}];
             none -> []
         end,
-    Headers1 = [{"content-type", fd_sfc_entry:mime_type(Entry)} | Headers0],
+    Headers1 = [{"content-type", fd_httpd_sfc_entry:mime_type(Entry)} | Headers0],
     Response = #response{headers = Headers1,
-                         body    = fd_sfc_entry:contents(Entry)},
+                         body    = fd_httpd_sfc_entry:contents(Entry)},
-    fd_http_utils:respond(Sock, Response);
+    fd_httpd_utils:respond(Sock, Response);
 respond_static(Sock, not_found) ->
-    fd_http_utils:http_err(Sock, 404).
+    fd_httpd_utils:http_err(Sock, 404).
 
 
-%% ------------------------------
-%% tetris
-%% ------------------------------
-
--spec ws_tetris(Sock, Request, Received) -> NewReceived
-    when Sock        :: gen_tcp:socket(),
-         Request     :: request(),
-         Received    :: binary(),
-         NewReceived :: binary().
-
-ws_tetris(Sock, Request, Received) ->
-    error(nyi).
-
-
-
--spec ws_tetris2(Sock, Request, Received) -> NewReceived
-    when Sock        :: gen_tcp:socket(),
-         Request     :: request(),
-         Received    :: binary(),
-         NewReceived :: binary().
-
-ws_tetris2(Sock, Request, Received) ->
-    %tell("~p: ws_tetris request: ~tp", [?LINE, Request]),
-    case qhl_ws:handshake(Request) of
-        {ok, Response} ->
-            fd_http_utils:respond(Sock, Response),
-            {ok, TetrisPid} = fd_tetris:start_link(),
-            ws_tetris_loop(Sock, TetrisPid, [], Received);
-        Error ->
-            tell("ws_tetris: error: ~tp", [Error]),
-            fd_http_utils:http_err(Sock, 400)
-    end.
-
-
--spec ws_tetris_loop(Sock, Tetris, Frames, Received) -> NewReceived
-    when Sock        :: gen_tcp:socket(),
-         Tetris      :: pid(),
-         Frames      :: [qhl_ws:frame()],
-         Received    :: binary(),
-         NewReceived :: binary().
-
-ws_tetris_loop(Sock, Tetris, Frames, Received) ->
-    tell("~p:ws_tetris_loop(Sock, ~p, ~p, ~p)", [?MODULE, Tetris, Frames, Received]),
-    %% create tetris state
-    case inet:setopts(Sock, [{active, once}]) of
-        ok ->
-            receive
-                {tcp, Sock, Bin} ->
-                    Rcv1 = <<Received/binary, Bin/binary>>,
-                    case qhl_ws:recv(Sock, Rcv1, 3_000, Frames) of
-                        {ok, WsMsg, NewFrames, Rcv2} ->
-                            ok = fd_tetris:ws_msg(Tetris, WsMsg),
-                            ws_tetris_loop(Sock, Tetris, NewFrames, Rcv2);
-                        Error ->
-                            error(Error)
-                    end;
-                {tetris, Message} ->
-                    ok = log(info, "~p tetris: ~p", [self(), Message]),
-                    ok = qhl_ws:send(Sock, {text, Message}),
-                    ws_tetris_loop(Sock, Tetris, Frames, Received);
-                {tcp_closed, Sock}        -> {error, tcp_closed};
-                {tcp_error, Sock, Reason} -> {error, {tcp_error, Reason}}
-            after 30_000 ->
-                {error, timeout}
-            end;
-        {error, Reason} ->
-            {error, {inet, Reason}}
-    end.
-
 %% ------------------------------
 %% echo
 %% ------------------------------
@@ -359,17 +289,17 @@ ws_echo(Sock, Request) ->
     catch
         X:Y:Z ->
             tell(error, "CRASH ws_echo: ~tp:~tp:~tp", [X, Y, Z]),
-            fd_http_utils:http_err(Sock, 500)
+            fd_httpd_utils:http_err(Sock, 500)
     end.
 
 ws_echo2(Sock, Request) ->
     case qhl_ws:handshake(Request) of
         {ok, Response} ->
-            fd_http_utils:respond(Sock, Response),
+            fd_httpd_utils:respond(Sock, Response),
             ws_echo_loop(Sock);
         Error ->
             tell("ws_echo: error: ~tp", [Error]),
-            fd_http_utils:http_err(Sock, 400)
+            fd_httpd_utils:http_err(Sock, 400)
     end.
 
 ws_echo_loop(Sock) ->
@@ -405,17 +335,17 @@ wfcin(Sock, #request{enctype = json,
             case wfc_read:expr(Input) of
                 {ok, Expr, _Rest} ->
                     case wfc_eval:eval(Expr, Ctx0) of
-                        {ok, noop, Ctx1}     -> {fd_http_utils:jsgud("<noop>"), Ctx1};
+                        {ok, noop, Ctx1}     -> {fd_httpd_utils:jsgud("<noop>"), Ctx1};
-                        {ok, Sentence, Ctx1} -> {fd_http_utils:jsgud(wfc_pp:sentence(Sentence)), Ctx1};
+                        {ok, Sentence, Ctx1} -> {fd_httpd_utils:jsgud(wfc_pp:sentence(Sentence)), Ctx1};
-                        {error, Message}     -> {fd_http_utils:jsbad(Message), Ctx0}
+                        {error, Message}     -> {fd_httpd_utils:jsbad(Message), Ctx0}
                     end;
                 {error, Message} ->
-                    {fd_http_utils:jsbad(Message), Ctx0}
+                    {fd_httpd_utils:jsbad(Message), Ctx0}
             end
         catch
             error:E:S ->
                 ErrorMessage = unicode:characters_to_list(io_lib:format("parser crashed: ~p:~p", [E, S])),
-                {fd_http_utils:jsbad(ErrorMessage), Ctx0}
+                {fd_httpd_utils:jsbad(ErrorMessage), Ctx0}
         end,
     % update cache with new context
     ok = fd_cache:set(Cookie, NewCtx),
@@ -423,10 +353,10 @@ wfcin(Sock, #request{enctype = json,
     Response = #response{headers = [{"content-type", "application/json"},
                                     {"set-cookie",   ["wfc=", Cookie]}],
                          body    = Body},
-    fd_http_utils:respond(Sock, Response);
+    fd_httpd_utils:respond(Sock, Response);
 wfcin(Sock, Request) ->
     tell("wfcin: bad request: ~tp", [Request]),
-    fd_http_utils:http_err(Sock, 400).
+    fd_httpd_utils:http_err(Sock, 400).
 
 
 
@@ -441,7 +371,7 @@ ctx(#{<<"wfc">> := Cookie}) ->
         error         -> {Cookie, wfc_eval_context:default()}
     end;
 ctx(_) ->
-    {fd_http_utils:new_cookie(), wfc_eval_context:default()}.
+    {fd_httpd_utils:new_cookie(), wfc_eval_context:default()}.
 
 
 

src/fd_httpd_client_man.erl

@@ -9,7 +9,7 @@
 %%% OTP should take care of for us.
 %%% @end
 
--module(fd_http_client_man).
+-module(fd_httpd_client_man).
 -vsn("0.1.0").
 -behavior(gen_server).
 -author("Peter Harpending <peterharpending@qpq.swiss>").
@@ -23,6 +23,8 @@
          code_change/3, terminate/2]).
 
 
+-include("$zx_include/zx_logger.hrl").
+
 %%% Type and Record Definitions
 
 
@@ -92,7 +94,7 @@ echo(Message) ->
     when Result :: {ok, pid()}
                  | {error, Reason :: term()}.
 %% @private
-%% This should only ever be called by fd_clients (the service-level supervisor).
+%% This should only ever be called by fd_httpd_clients (the service-level supervisor).
 
 start_link() ->
     gen_server:start_link({local, ?MODULE}, ?MODULE, none, []).
@@ -104,8 +106,9 @@ start_link() ->
 %% preparatory work necessary for proper function.
 
 init(none) ->
-    ok = io:format("Starting.~n"),
+    ok = tell("Starting fd_httpd_client_man."),
     State = #s{},
+    ok = tell("fd_httpd_client_man init state: ~tp", [State]),
     {ok, State}.
 
 
@@ -130,7 +133,7 @@ handle_call({listen, PortNum}, _, State) ->
     {Response, NewState} = do_listen(PortNum, State),
     {reply, Response, NewState};
 handle_call(Unexpected, From, State) ->
-    ok = io:format("~p Unexpected call from ~tp: ~tp~n", [self(), From, Unexpected]),
+    ok = tell("~p Unexpected call from ~tp: ~tp~n", [self(), From, Unexpected]),
     {noreply, State}.
 
 
@@ -152,7 +155,7 @@ handle_cast(ignore, State) ->
     NewState = do_ignore(State),
     {noreply, NewState};
 handle_cast(Unexpected, State) ->
-    ok = io:format("~p Unexpected cast: ~tp~n", [self(), Unexpected]),
+    ok = tell("~p Unexpected cast: ~tp~n", [self(), Unexpected]),
     {noreply, State}.
 
 
@@ -168,7 +171,7 @@ handle_info({'DOWN', Mon, process, Pid, Reason}, State) ->
     NewState = handle_down(Mon, Pid, Reason, State),
     {noreply, NewState};
 handle_info(Unexpected, State) ->
-    ok = io:format("~p Unexpected info: ~tp~n", [self(), Unexpected]),
+    ok = tell("~p Unexpected info: ~tp~n", [self(), Unexpected]),
     {noreply, State}.
 
 
@@ -225,10 +228,10 @@ do_listen(PortNum, State = #s{port_num = none}) ->
          {keepalive, true},
          {reuseaddr, true}],
     {ok, Listener} = gen_tcp:listen(PortNum, SocketOptions),
-    {ok, _} = fd_client:start(Listener),
+    {ok, _} = fd_httpd_client:start(Listener),
     {ok, State#s{port_num = PortNum, listener = Listener}};
 do_listen(_, State = #s{port_num = PortNum}) ->
-    ok = io:format("~p Already listening on ~p~n", [self(), PortNum]),
+    ok = tell("~p Already listening on ~p~n", [self(), PortNum]),
     {{error, {listening, PortNum}}, State}.
 
 
@@ -254,7 +257,7 @@ do_enroll(Pid, State = #s{clients = Clients}) ->
     case lists:member(Pid, Clients) of
         false ->
             Mon = monitor(process, Pid),
-            ok = io:format("Monitoring ~tp @ ~tp~n", [Pid, Mon]),
+            ok = tell("Monitoring ~tp @ ~tp~n", [Pid, Mon]),
             State#s{clients = [Pid | Clients]};
         true ->
             State
@@ -292,6 +295,6 @@ handle_down(Mon, Pid, Reason, State = #s{clients = Clients}) ->
             State#s{clients = NewClients};
         false ->
             Unexpected = {'DOWN', Mon, process, Pid, Reason},
-            ok = io:format("~p Unexpected info: ~tp~n", [self(), Unexpected]),
+            ok = tell("~p Unexpected info: ~tp~n", [self(), Unexpected]),
             State
     end.

src/fd_httpd_client_sup.erl

@@ -2,8 +2,8 @@
 %%% front end web development lab Client Supervisor
 %%%
 %%% This process supervises the client socket handlers themselves. It is a peer of the
-%%% fd_client_man (the manager interface to this network service component),
+%%% fd_httpd_client_man (the manager interface to this network service component),
-%%% and a child of the supervisor named fd_clients.
+%%% and a child of the supervisor named fd_httpd_clients.
 %%%
 %%% Because we don't know (or care) how many client connections the server may end up
 %%% handling this is a simple_one_for_one supervisor which can spawn and manage as
@@ -13,7 +13,7 @@
 %%% http://erlang.org/doc/design_principles/sup_princ.html#id79244
 %%% @end
 
--module(fd_http_client_sup).
+-module(fd_httpd_client_sup).
 -vsn("0.1.0").
 -behaviour(supervisor).
 -author("Peter Harpending <peterharpending@qpq.swiss>").
@@ -35,9 +35,9 @@
                        | {shutdown, term()}
                        | term().
 %% @private
-%% Spawns the first listener at the request of the fd_client_man when
+%% Spawns the first listener at the request of the fd_httpd_client_man when
 %% fewd:listen/1 is called, or the next listener at the request of the
-%% currently listening fd_client when a connection is made.
+%% currently listening fd_httpd_client when a connection is made.
 %%
 %% Error conditions, supervision strategies and other important issues are
 %% explained in the supervisor module docs:
@@ -61,10 +61,10 @@ start_link() ->
 
 init(none) ->
     RestartStrategy = {simple_one_for_one, 1, 60},
-    Client    = {fd_client,
+    Client    = {fd_httpd_client,
-                 {fd_client, start_link, []},
+                 {fd_httpd_client, start_link, []},
                  temporary,
                  brutal_kill,
                  worker,
-                 [fd_client]},
+                 [fd_httpd_client]},
     {ok, {RestartStrategy, [Client]}}.

src/fd_httpd_clients.erl

@@ -8,7 +8,7 @@
 %%% See: http://erlang.org/doc/apps/kernel/application.html
 %%% @end
 
--module(fd_http).
+-module(fd_httpd_clients).
 -vsn("0.1.0").
 -behavior(supervisor).
 -author("Peter Harpending <peterharpending@qpq.swiss>").
@@ -32,17 +32,17 @@ start_link() ->
 
 init(none) ->
     RestartStrategy = {rest_for_one, 1, 60},
-    HttpClientMan = {fd_http_client_man,
+    HttpClientMan = {fd_httpd_client_man,
-                     {fd_http_client_man, start_link, []},
+                     {fd_httpd_client_man, start_link, []},
                      permanent,
                      5000,
                      worker,
-                     [fd_http_client_man]},
+                     [fd_httpd_client_man]},
-    HttpClientSup = {fd_http_client_sup,
+    HttpClientSup = {fd_httpd_client_sup,
-                     {fd_http_client_sup, start_link, []},
+                     {fd_httpd_client_sup, start_link, []},
                      permanent,
                      5000,
                      supervisor,
-                     [fd_http_client_sup]},
+                     [fd_httpd_client_sup]},
     Children  = [HttpClientSup, HttpClientMan],
     {ok, {RestartStrategy, Children}}.

src/fd_httpd_sfc.erl

@@ -1,5 +1,5 @@
 % @doc static file cache
--module(fd_sfc).
+-module(fd_httpd_sfc).
 
 -behavior(gen_server).
 
@@ -21,12 +21,12 @@
 
 -include("$zx_include/zx_logger.hrl").
 
--type entry()       :: fd_sfc_entry:entry().
+-type entry()       :: fd_httpd_sfc_entry:entry().
--type maybe_entry() :: {found, fd_sfc_entry:entry()} | not_found.
+-type maybe_entry() :: {found, fd_httpd_sfc_entry:entry()} | not_found.
 
 
 -record(s, {base_path  = base_path()                   :: file:filename(),
-            cache      = fd_sfc_cache:new(base_path()) :: fd_sfc_cache:cache(),
+            cache      = fd_httpd_sfc_cache:new(base_path()) :: fd_httpd_sfc_cache:cache(),
             auto_renew = 0_500                         :: pos_integer()}).
 %-type state() :: #s{}.
 
@@ -62,14 +62,14 @@ start_link() ->
 %% gen_server callbacks
 
 init(none) ->
-    tell("starting fd_sfc"),
+    tell("starting fd_httpd_sfc"),
     InitState = #s{},
     erlang:send_after(InitState#s.auto_renew, self(), auto_renew),
     {ok, InitState}.
 
 
 handle_call({query, Path}, _, State = #s{cache = Cache}) ->
-    Reply = fd_sfc_cache:query(Path, Cache),
+    Reply = fd_httpd_sfc_cache:query(Path, Cache),
     {reply, Reply, State};
 handle_call(Unexpected, From, State) ->
     tell("~tp: unexpected call from ~tp: ~tp", [?MODULE, Unexpected, From]),
@@ -106,6 +106,6 @@ terminate(_, _) ->
 %%-----------------------------------------------------------------------------
 
 i_renew(State = #s{base_path = BasePath}) ->
-    NewCache = fd_sfc_cache:new(BasePath),
+    NewCache = fd_httpd_sfc_cache:new(BasePath),
     NewState = State#s{cache = NewCache},
     NewState.

src/fd_httpd_sfc_cache.erl

@@ -1,6 +1,6 @@
 % @doc
 % cache data management
--module(fd_sfc_cache).
+-module(fd_httpd_sfc_cache).
 
 -export_type([
     cache/0
@@ -13,7 +13,7 @@
 
 -include("$zx_include/zx_logger.hrl").
 
--type cache() :: #{HttpPath :: binary() := Entry :: fd_sfc_entry:entry()}.
+-type cache() :: #{HttpPath :: binary() := Entry :: fd_httpd_sfc_entry:entry()}.
 
 
 -spec query(HttpPath, Cache) -> Result
@@ -21,7 +21,7 @@
          Cache    :: cache(),
          Result   :: {found, Entry}
                    | not_found,
-         Entry    :: fd_sfc_entry:entry().
+         Entry    :: fd_httpd_sfc_entry:entry().
 
 query(HttpPath, Cache) ->
     case maps:find(HttpPath, Cache) of
@@ -63,7 +63,7 @@ new2(BasePath) ->
             BAbsPath = unicode:characters_to_binary(AbsPath),
             HttpPath = remove_prefix(BBaseDir, BAbsPath),
             NewCache =
-                case fd_sfc_entry:new(AbsPath) of
+                case fd_httpd_sfc_entry:new(AbsPath) of
                     {found, Entry} -> maps:put(HttpPath, Entry, AccCache);
                     not_found      -> AccCache
                 end,

src/fd_httpd_sfc_entry.erl

@@ -1,7 +1,7 @@
 % @doc non-servery functions for static file caching
 %
 % this spams the filesystem, so it's not "pure" code
--module(fd_sfc_entry).
+-module(fd_httpd_sfc_entry).
 
 -export_type([
     encoding/0,

src/fd_httpd_utils.erl

@@ -1,5 +1,5 @@
 % @doc http utility functions
--module(fd_http_utils).
+-module(fd_httpd_utils).
 
 -export([
     new_cookie/0,

src/fd_sup.erl

@@ -36,29 +36,17 @@ start_link() ->
 
 init([]) ->
     RestartStrategy = {one_for_one, 1, 60},
-    Httpd     = {fd_http,
-                 {fd_http, start_link, []},
-                 permanent,
-                 5000,
-                 supervisor,
-                 [fd_clients]},
-    Chat      = {fd_chat,
-                 {fd_chat, start_link, []},
-                 permanent,
-                 5000,
-                 worker,
-                 [fd_chat]},
-    FileCache = {fd_sfc,
-                 {fd_sfc, start_link, []},
-                 permanent,
-                 5000,
-                 worker,
-                 [fd_sfc]},
     Cache     = {fd_cache,
                  {fd_cache, start_link, []},
                  permanent,
                  5000,
                  worker,
                  [fd_cache]},
-    Children  = [Httpd, Chat, FileCache, Cache],
+    Httpd     = {fd_httpd,
+                 {fd_httpd, start_link, []},
+                 permanent,
+                 5000,
+                 supervisor,
+                 [fd_httpd]},
+    Children  = [Cache, Httpd],
     {ok, {RestartStrategy, Children}}.

src/fd_tetris.erl

@@ -1,88 +0,0 @@
-% @doc tetris
-%
-% manages state for a single game of tetris
-%
-% sends parent process messages `{tetris, String}` where String is an encoded
-% JSON blob meant to be sent to the page script in /priv/static/js/ts/tetris.ts
-%
-% Refs:
-% 1. https://www.erlang.org/docs/24/man/gen_server
--module(fd_tetris).
-
--behavior(gen_server).
-
--export([
-    %% caller context
-    start_link/0,
-    %% process context
-    %% gen_server callbacks
-    init/1, handle_call/3, handle_cast/2, handle_info/2,
-    code_change/3, terminate/2
-]).
-
--include("$zx_include/zx_logger.hrl").
-
-
--record(s, {parent :: pid()}).
-
--type state() :: #s{}.
-
-%%-----------------------------------------------------------------------------
-%% caller context below this line
-%%-----------------------------------------------------------------------------
-
--spec ws_msg(Tetris, Message) -> ok
-    when Tetris  :: pid(),
-         Message :: qhl_ws:ws_msg().
-
-ws_msg(Tetris, Msg) ->
-    gen_server:cast(Tetris, {ws_msg, Msg}).
-
-
--spec start_link() -> {ok, pid()} | {error, term()}.
-start_link() ->
-    gen_server:start_link(?MODULE, [self()], []).
-
-
-%%-----------------------------------------------------------------------------
-%% process context below this line
-%%-----------------------------------------------------------------------------
-
-%% gen_server callbacks
-
--spec init(Args) -> {ok, State}
-    when Args   :: [Parent],
-         Parent :: pid(),
-         State  :: state().
-
-init([Parent]) ->
-    tell("~tp:~tp starting fd_tetris with parent ~p", [?MODULE, self(), Parent]),
-    self() ! {poop, 0},
-    InitState = #s{parent = Parent},
-    {ok, InitState}.
-
-
-handle_call(Unexpected, From, State) ->
-    tell("~tp:~tp unexpected call from ~tp: ~tp", [?MODULE, self(), From, Unexpected]),
-    {noreply, State}.
-
-
-handle_cast(Unexpected, State) ->
-    tell("~tp:~tp unexpected cast: ~tp", [?MODULE, self(), Unexpected]),
-    {noreply, State}.
-
-
-handle_info({poop, N}, State = #s{parent = Parent}) ->
-    Parent ! {tetris, io_lib:format("poop~p", [N])},
-    erlang:send_after(1_000, self(), {poop, N+1}),
-    {noreply, State};
-handle_info(Unexpected, State) ->
-    tell("~tp:~tp unexpected info: ~tp", [?MODULE, self(), Unexpected]),
-    {noreply, State}.
-
-
-code_change(_, State, _) ->
-    {ok, State}.
-
-terminate(_, _) ->
-    ok.

src/fewd.erl

@@ -24,7 +24,7 @@
 %% Returns an {error, Reason} tuple if it is already listening.
 
 listen(PortNum) ->
-    fd_http:listen(PortNum).
+    fd_httpd_client_man:listen(PortNum).
 
 
 -spec ignore() -> ok.
@@ -32,7 +32,7 @@ listen(PortNum) ->
 %% Make the server stop listening if it is, or continue to do nothing if it isn't.
 
 ignore() ->
-    fd_http:ignore().
+    fd_httpd_client_man:ignore().
 
 
 -spec start(normal, term()) -> {ok, pid()}.