Rudimentary socket connections are working

Really basic, hacky, janky socket connections are working: I can run
`ChorexExamples.start_server()` and then run `nc localhost 4242`,
transmit 100 bytes, and get a response back! Amazing!

Author: ashton314

lib/chorex_examples.ex

@@ -15,4 +15,12 @@ defmodule ChorexExamples do
   def hello do
     :world
   end
+
+  def start_server() do
+    Chorex.start(
+      Tcp.ListenerChor.Chorex,
+      %{Listener => Tcp.ListenerImpl, AccepterPool => Tcp.AccepterPoolImpl},
+      [%{port: 4242, user_options: []}]
+    )
+  end
 end

lib/http/Client.ex

@@ -4,7 +4,7 @@ defmodule Http.Client do
   def get_headers() do
     receive do
       # This has to come in from elsewhere
-	  {:socket, s} ->
+      {:socket, s} ->
         read_headers(s)
     end
   end
@@ -13,14 +13,14 @@ defmodule Http.Client do
   end
 
   def finish_request(nil) do
-	# close request
+    # close request
   end
 
   #
   # Helper functions
   #
 
-  def read_headers(sock) do
+  def read_headers(_sock) do
     # ...
   end
 end

lib/http/chor.ex

@@ -2,16 +2,19 @@ defmodule Http.Chor do
   import Chorex
 
   defchor [Client, Server] do
-    Client.get_headers() ~> Server.(headers)
-    if Server.accept?(headers) do
-      Server[L] ~> Client
-      Server.accept_length(headers) ~> Client.(body_length)
-      Client.get_body(body_length) ~> Server.(body)
-      Server.handle(headers, body) ~> Client.(response)
-      Client.finish_request(response)
-    else
-      Server[R] ~> Client
-      Client.finish_request(nil)
+    def run(_) do
+      Client.get_headers() ~> Server.(headers)
+
+      if Server.accept?(headers) do
+        Server[L] ~> Client
+        Server.accept_length(headers) ~> Client.(body_length)
+        Client.get_body(body_length) ~> Server.(body)
+        Server.handle(headers, body) ~> Client.(response)
+        Client.finish_request(response)
+      else
+        Server[R] ~> Client
+        Client.finish_request(nil)
+      end
     end
   end
 end

lib/http/server.ex

@@ -5,10 +5,10 @@ defmodule Http.Server do
   end
 
   def accept?(_headers) do
-	false
+    false
   end
 
   def accept_length(_headers) do
-	42
+    42
   end
 end

lib/tcp/accepter_pool_impl.ex

@@ -1,7 +1,16 @@
 defmodule Tcp.AccepterPoolImpl do
   use Tcp.ListenerChor.Chorex, :accepterpool
 
-  def spawn_handler(_socket) do
-	# startup instance of the handler choreography
+  def accept_and_handle_connection(listen_socket) do
+    IO.inspect(listen_socket, label: "[accepter_pool] socket")
+
+    {:ok, socket} = :gen_tcp.accept(listen_socket)
+
+    # startup instance of the handler choreography
+    Chorex.start(
+      Tcp.HandlerChor.Chorex,
+      %{Handler => Tcp.HandlerImpl, TcpClient => Tcp.ClientImpl},
+      [socket]
+    )
   end
 end

lib/tcp/client_impl.ex

@@ -1,6 +1,12 @@
 defmodule Tcp.ClientImpl do
   use Tcp.HandlerChor.Chorex, :tcpclient
 
-  def send_over_socket(_sock, _msg) do
+  def read(sock) do
+    :gen_tcp.recv(sock, 100)
+  end
+
+  def send_over_socket(sock, msg) do
+    IO.inspect(msg, label: "[client] msg")
+    :gen_tcp.send(sock, msg)
   end
 end

lib/tcp/handler_chor.ex

@@ -2,49 +2,20 @@ defmodule Tcp.HandlerChor do
   import Chorex
 
   defchor [Handler, TcpClient] do
-    def loop(TcpClient.(sock)) do
-      with Handler.(resp) <- Handler.run() do
+    def run(TcpClient.(sock)) do
+      TcpClient.read(sock) ~> Handler.(msg)
+      with Handler.(resp) <- Handler.run(msg) do
         if Handler.continue?(resp) do
           Handler[L] ~> TcpClient
           Handler.fmt_reply(resp) ~> TcpClient.(resp)
           TcpClient.send_over_socket(sock, resp)
-          loop(TcpClient.(sock))
+          run(TcpClient.(sock))
         else
           Handler[R] ~> TcpClient
           Handler.fmt_reply(resp) ~> TcpClient.(resp)
           TcpClient.send_over_socket(sock, resp)
         end
       end
     end
-
-    def init(TcpClient.(sock)) do
-      loop(TcpClient.(sock))
-    end
   end
-
-  # quote do
-  #   defchor [Handler, TcpClient] do
-  #     def loop(TcpClient.(sock)) do
-  #       with Handler.(resp) <- Handler.run() do
-  #         if Handler.continue?(resp) do
-  #           Handler[L] ~> TcpClient
-  #           Handler.fmt_reply(resp) ~> TcpClient.(resp)
-  #           TcpClient.send_over_socket(sock, resp)
-  #           loop(TcpClient.(sock))
-  #         else
-  #           Handler[R] ~> TcpClient
-  #           Handler.fmt_reply(resp) ~> TcpClient.(resp)
-  #           TcpClient.send_over_socket(sock, resp)
-  #         end
-  #       end
-  #     end
-
-  #     def init(TcpClient.(sock)) do
-  #       loop(TcpClient.(sock))
-  #     end
-  #   end
-  # end
-  # |> Macro.expand_once(__ENV__)
-  # |> Macro.to_string()
-  # |> IO.puts()
 end

lib/tcp/handler_impl.ex

@@ -1,12 +1,13 @@
 defmodule Tcp.HandlerImpl do
   use Tcp.HandlerChor.Chorex, :handler
 
-  def run() do
+  def run(msg) do
+    IO.inspect(msg, label: "[handler] msg")
+    {:halt, "you did it!"}
   end
 
   def continue?({:continue, _resp}), do: true
   def continue?({:halt, _resp}), do: false
 
   def fmt_reply({_status, resp}), do: resp
-
 end

lib/tcp/listener_chor.ex

@@ -2,12 +2,29 @@ defmodule Tcp.ListenerChor do
   import Chorex
 
   defchor [Listener, AccepterPool] do
-    def loop(Listener.(_x)) do
-      Listener.await_connection() ~> AccepterPool.(socket)
-      AccepterPool.spawn_handler(socket)
-      loop(Listener.(nil))
+    def run(Listener.(config)) do
+      Listener.get_listener_socket(config) ~> AccepterPool.({:ok, socket})
+      loop(AccepterPool.(socket))
     end
 
-    loop(Listener.(nil))
+    def loop(AccepterPool.(listen_socket)) do
+      AccepterPool.accept_and_handle_connection(listen_socket)
+      loop(AccepterPool.(listen_socket))
+    end
   end
+
+  # # Tcp.ListenerChor.Chorex
+  # defchor [Listener, AccepterPool] do
+  #   alias Tcp.HandlerChor
+
+  #   def run(Listener.(config)) do
+  #     Listener.await_connection(config) ~> AccepterPool.({:ok, socket})
+
+  #     sub_chor(HandlerChor.Chorex,
+  #       supervisor: AcceptorPool,
+  #       args: [AccepterPool.(socket)])
+
+  #     run(Listener.(config))
+  #   end
+  # end
 end

lib/tcp/listener_impl.ex

@@ -1,7 +1,28 @@
 defmodule Tcp.ListenerImpl do
   use Tcp.ListenerChor.Chorex, :listener
 
-  def await_connection() do
-    42
+  @hardcoded_options [mode: :binary, active: false]
+
+  def get_listener_socket(config) do
+    default_options = [
+      backlog: 1024,
+      nodelay: true,
+      send_timeout: 30_000,
+      send_timeout_close: true,
+      reuseaddr: true
+    ]
+
+    opts =
+      Enum.uniq_by(
+        @hardcoded_options ++ config[:user_options] ++ default_options,
+        fn
+          {key, _} when is_atom(key) -> key
+          key when is_atom(key) -> key
+        end
+      )
+
+    # Hopefully returns {:ok, :inet.socket()}
+    :gen_tcp.listen(config[:port], opts)
+    |> IO.inspect(label: "listener socket")
   end
 end