Add store and retrieve endpoints (#22)

.travis.yml

@@ -3,11 +3,11 @@ notifications:
   recipients:
     - eduardo@gurgel.me
 elixir:
-  - 1.2.4
+  - 1.2.6
   - 1.3.0
 otp_release:
   - 18.0
   - 18.1
   - 19.0
 sudo: false
-script: mix test --no-start
+script: mix test

lib/httparrot.ex

@@ -1,5 +1,10 @@
 defmodule HTTParrot do
   use Application
+  use Supervisor
+
+  def start_link(arg) do
+    Supervisor.start_link(__MODULE__, arg)
+  end
 
   def start(_type, _args) do
     dispatch = :cowboy_router.compile([
@@ -32,7 +37,9 @@ defmodule HTTParrot do
              {'/base64/:value', HTTParrot.Base64Handler, []},
              {'/image', HTTParrot.ImageHandler, []},
              {'/websocket', HTTParrot.WebsocketHandler, []},
-             {'/response-headers', HTTParrot.ResponseHeadersHandler, []} ] }
+             {'/response-headers', HTTParrot.ResponseHeadersHandler, []},
+             {'/store/:key', HTTParrot.StoreRequestHandler, []},
+             {'/retrieve/:key', HTTParrot.RetrieveRequestHandler, []} ] }
     ])
 
     {:ok, http_port} = Application.fetch_env(:httparrot, :http_port)
@@ -51,8 +58,12 @@ defmodule HTTParrot do
          certfile: priv_dir ++ '/ssl/server.crt', keyfile: priv_dir ++ '/ssl/server.key'],
         [env: [dispatch: dispatch], onresponse: &prettify_json/4])
     end
-
+    Supervisor.start_link([
-    Supervisor.start_link([], strategy: :one_for_one)
+        worker(ConCache, [[
+            ttl_check: :timer.minutes(5),
+            ttl: :timer.hours(12)
+          ], [name: :requests_registry]])
+      ], strategy: :one_for_one)
   end
 
   def stop(_State), do: :ok

lib/httparrot/p_handler.ex

@@ -49,7 +49,7 @@ defmodule HTTParrot.PHandler do
     end
   end
 
-  defp handle_binary(req, chunks \\ []) do
+  def handle_binary(req, chunks \\ []) do
     case :cowboy_req.body(req) do
       {:ok, chunk, req} ->
         {:ok, Enum.join(chunks ++ [chunk]), req}
@@ -77,7 +77,7 @@ defmodule HTTParrot.PHandler do
     post(req, [form: normalize_list(form_parts), files: normalize_list(file_parts), data: "", json: nil])
   end
 
-  defp handle_multipart(req, parts \\ []) do
+  def handle_multipart(req, parts \\ []) do
     case :cowboy_req.part(req) do
       {:done, req} -> {:ok, parts, req}
       {:ok, headers, req} ->
@@ -121,7 +121,7 @@ defmodule HTTParrot.PHandler do
     end
   end
 
-  defp normalize_list([]), do: [{}]
+  def normalize_list([]), do: [{}]
 
-  defp normalize_list(list), do: list
+  def normalize_list(list), do: list
 end

lib/httparrot/request_store.ex

@@ -0,0 +1,31 @@
+defmodule HTTParrot.RequestStore do
+  @moduledoc """
+  Used to store and retrived requests
+  """
+  @doc """
+  Store the requests to the key
+  """
+  def store(key, info) do
+    map = retrieve(key) ++ [info]
+    ConCache.put(:requests_registry, key, map)
+  end
+
+  @doc """
+  Get the saved request using the key
+  """
+  def retrieve(key) do
+    entry = ConCache.get(:requests_registry, key)
+    case entry do
+    nil -> []
+    _ ->
+      entry
+    end
+  end
+
+  @doc """
+  Clear the saved data on the coresponding key
+  """
+  def clear(key) do
+    ConCache.delete(:requests_registry, key)
+  end
+end

lib/httparrot/retrieve_request_handler.ex

@@ -0,0 +1,22 @@
+defmodule HTTParrot.RetrieveRequestHandler do
+  @moduledoc """
+  Retreive saved request and clear the conresponding :id
+  """
+  alias HTTParrot.GeneralRequestInfo
+  use HTTParrot.Cowboy, methods: ~w(GET POST PUT HEAD OPTIONS)
+
+  def content_types_provided(req, state) do
+    {[{{"application", "json", []}, :retrieve_stored}], req, state}
+  end
+
+  def retrieve_stored(req, state) do
+    {key, _} = :cowboy_req.binding(:key, req)
+    requests = HTTParrot.RequestStore.retrieve(key)
+    HTTParrot.RequestStore.clear(key)
+    {response(requests), req, state}
+  end
+
+  defp response(info) do
+    info |> JSX.encode!
+  end
+end

lib/httparrot/store_request_handler.ex

@@ -0,0 +1,66 @@
+defmodule HTTParrot.StoreRequestHandler do
+  @moduledoc """
+  Store the sended request with the :id
+  """
+  alias HTTParrot.GeneralRequestInfo
+  use HTTParrot.Cowboy, methods: ~w(GET POST PUT HEAD OPTIONS)
+
+  def content_types_accepted(req, state) do
+    {[{{"application", "json", :*}, :post_binary},
+      {{"application", "octet-stream", :*}, :post_binary},
+      {{"text", "plain", :*}, :post_binary},
+      {{"application", "x-www-form-urlencoded", :*}, :post_form},
+      {{"multipart", "form-data", :*}, :post_multipart}], req, state}
+  end
+
+  def content_types_provided(req, state) do
+    {[{{"application", "json", []}, :get}], req, state}
+  end
+
+  def get(req, state) do
+    {info, req} = GeneralRequestInfo.retrieve(req)
+    {key, _} = :cowboy_req.binding(:key, req)
+    HTTParrot.RequestStore.store(key, info)
+    {'{"saved":  "true"}', req, state}
+  end
+
+  def post_binary(req, _state) do
+    {:ok, body, req} = HTTParrot.PHandler.handle_binary(req)
+    if String.valid?(body) do
+      if JSX.is_json?(body) do
+        save_post(req, [form: [{}], data: body, json: JSX.decode!(body)])
+      else
+        save_post(req, [form: [{}], data: body, json: nil])
+      end
+    else
+      # Octet-stream
+      body = Base.encode64(body)
+      save_post(req, [form: [{}], data: "data:application/octet-stream;base64," <> body, json: nil])
+    end
+  end
+
+  def post_form(req, _state) do
+    {:ok, body, req} = :cowboy_req.body_qs(req)
+    save_post(req, [form: body, data: "", json: nil])
+  end
+
+  def post_multipart(req, _state) do
+    {:ok, parts, req} = HTTParrot.PHandler.handle_multipart(req)
+
+    file_parts = for file <- parts, elem(file, 0) == :file, do: {elem(file, 1), elem(file, 2)}
+    form_parts = for form <- parts, elem(form, 0) == :form, do: {elem(form, 1), elem(form, 2)}
+
+    save_post(req, [form: HTTParrot.PHandler.normalize_list(form_parts),
+                    files: HTTParrot.PHandler.normalize_list(file_parts),
+                    data: "", json: nil])
+  end
+
+  def save_post(req, body) do
+    {info, req} = GeneralRequestInfo.retrieve(req)
+    {key, req} = :cowboy_req.binding(:key, req)
+    HTTParrot.RequestStore.store(key, info ++ body)
+    {:ok, req} = :cowboy_req.reply(200, [], '{"saved":  "true"}', req)
+    {:halt, req, nil}
+  end
+
+end

mix.exs

@@ -19,7 +19,8 @@ defmodule Httparrot.Mixfile do
     [ applications: [ :compiler,
                       :syntax_tools,
                       :cowboy,
-                      :exjsx ],
+                      :exjsx,
+                      :con_cache ],
       mod: { HTTParrot, [] },
       env: [ http_port: 8080, ssl: true, https_port: 8433 ] ]
   end
@@ -27,6 +28,7 @@ defmodule Httparrot.Mixfile do
   defp deps do
     [ {:cowboy, "~> 1.0.0"},
       {:exjsx, "~> 3.0"},
+      {:con_cache, "~> 0.11.1"},
       {:ex_doc, ">= 0.0.0", only: :dev},
       {:meck, "~> 0.8.2", only: :test } ]
   end

mix.lock

@@ -1,7 +1,9 @@
-%{"cowboy": {:hex, :cowboy, "1.0.0", "d0b46a5e5f971c5543eb46f86fe76b9add567d12fb5262a852b8f27c64c0555d", [:make, :rebar], [{:cowlib, "~> 1.0.0", [hex: :cowlib, optional: false]}, {:ranch, "~> 1.0", [hex: :ranch, optional: false]}]},
+%{"con_cache": {:hex, :con_cache, "0.11.1", "acbe5a1d10c47faba30d9629c9121e1ef9bca0aa5eddbb86f4e777bd9f9f9b6f", [:mix], [{:exactor, "~> 2.2.0", [hex: :exactor, optional: false]}]},
+  "cowboy": {:hex, :cowboy, "1.0.0", "d0b46a5e5f971c5543eb46f86fe76b9add567d12fb5262a852b8f27c64c0555d", [:make, :rebar], [{:cowlib, "~> 1.0.0", [hex: :cowlib, optional: false]}, {:ranch, "~> 1.0", [hex: :ranch, optional: false]}]},
   "cowlib": {:hex, :cowlib, "1.0.0", "397d890d669e56d486b0b5329973ad1a07012412bc110d34a737698dd6941741", [:make], []},
   "earmark": {:hex, :earmark, "1.0.1", "2c2cd903bfdc3de3f189bd9a8d4569a075b88a8981ded9a0d95672f6e2b63141", [:mix], []},
   "ex_doc": {:hex, :ex_doc, "0.13.0", "aa2f8fe4c6136a2f7cfc0a7e06805f82530e91df00e2bff4b4362002b43ada65", [:mix], [{:earmark, "~> 1.0", [hex: :earmark, optional: false]}]},
+  "exactor": {:hex, :exactor, "2.2.2", "90b27d72c05614801a60f8400afd4e4346dfc33ea9beffe3b98a794891d2ff96", [:mix], []},
   "exjsx": {:hex, :exjsx, "3.1.0", "d419162cb2d5be80070835c2c2b8c78c8c45907706c991d23f3750dae506d1e9", [:mix], [{:jsx, "~> 2.4.0", [hex: :jsx, optional: false]}]},
   "jsx": {:hex, :jsx, "2.4.0", "fb83830ac15e981b6ce310b645324ceecd01b1e0847d23921c33df829de5d2db", [:mix], []},
   "meck": {:hex, :meck, "0.8.2", "f15f7d513e14ec8c8dee9a95d4ae585b3e5a88bf0fa6a7573240d6ddb58a7236", [:make, :rebar], []},

test/request_store_test.exs

@@ -0,0 +1,12 @@
+defmodule HTTParrot.RequestStoreTest do
+  alias HTTParrot.RequestStore
+  use ExUnit.Case
+  test "save, retrieve, clear" do
+    request = %{req: 1}
+    RequestStore.clear(:test)
+    RequestStore.store(:test, request)
+    assert RequestStore.retrieve(:test) == [request]
+     RequestStore.clear(:test)
+    assert RequestStore.retrieve(:test) == []
+  end
+end

test/retrieve_request_handler_tests.exs

@@ -0,0 +1,17 @@
+defmodule HTTParrot.RetrieveRequestHandlerTests do
+  use ExUnit.Case
+  import :meck
+  import HTTParrot.RetrieveRequestHandler
+
+  setup do
+    HTTParrot.RequestStore.clear(:test)
+    on_exit fn -> unload end
+    :ok
+  end
+
+  test "returns saved requests" do
+    expect(:cowboy_req, :binding, [:key, :req1], {:test, :req1})
+    HTTParrot.RequestStore.store(:test, :req1)
+    assert retrieve_stored(:req1, :state) == {"[\"req1\"]", :req1, :state}
+  end
+end

test/store_request_handler_test.exs

@@ -0,0 +1,26 @@
+defmodule HTTParrot.StoreRequestHandlerTests do
+  use ExUnit.Case
+  import :meck
+  import HTTParrot.StoreRequestHandler
+
+  setup do
+    HTTParrot.RequestStore.clear(:test)
+    on_exit fn -> unload end
+    :ok
+  end
+
+  test "store a request" do
+    expect(:cowboy_req, :binding, [:key, :req1], {:test, :req1})
+    expect(HTTParrot.GeneralRequestInfo, :retrieve, 1, {:info, :req1})
+    assert get(:req1, :state) == {'{"saved":  "true"}', :req1, :state}
+    assert HTTParrot.RequestStore.retrieve(:test) == [:info]
+  end
+
+  test "store multiple requests" do
+    expect(:cowboy_req, :binding, [:key, :req1], {:test, :req1})
+    expect(HTTParrot.GeneralRequestInfo, :retrieve, 1, {:info, :req1})
+    assert get(:req1, :state) == {'{"saved":  "true"}', :req1, :state}
+    assert get(:req2, :state) == {'{"saved":  "true"}', :req1, :state}
+    assert HTTParrot.RequestStore.retrieve(:test) == [:info, :info]
+  end
+end