pools connections to the graph

Author: mneudert

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - Enhancements
   - Allows retrieving the shape of a query
+  - Pools connections to the graph
   - Uses `:hackney` instead of `:inets`
 
 - Backwards incompatible changes

README.md

@@ -45,6 +45,7 @@ They only need to be linked to an entry in your `config.exs`:
 ```elixir
 config :my_app, MyApp.MyGraph,
   host: "localhost",
+  pool: [ max_overflow: 0, size: 1 ],
   port: 64210
 ```
 

config/test.exs

@@ -2,4 +2,5 @@ use Mix.Config
 
 config :caylir_test, Caylir.TestHelpers.Graph,
   host: "localhost",
+  pool: [ max_overflow: 0, size: 1 ],
   port: 64210

lib/caylir/graph.ex

@@ -15,25 +15,33 @@ defmodule Caylir.Graph do
 
       config :my_application, MyGraph,
         host: "localhost",
+        pool: [ max_overflow: 10, size: 5 ],
         port: 64210
   """
 
   use Behaviour
 
   defmacro __using__(otp_app: otp_app) do
     quote do
-      alias Caylir.Graph.Connection
+      alias Caylir.Graph.Config
+      alias Caylir.Graph.Pool
 
       @behaviour unquote(__MODULE__)
       @otp_app   unquote(otp_app)
 
-      def child_spec, do: Connection.child_spec(__MODULE__)
-      def config,     do: Connection.Config.config(@otp_app, __MODULE__)
+      def __pool__, do: __MODULE__.Pool
 
-      def delete(quad), do: Connection.delete(__MODULE__, quad)
-      def query(query), do: Connection.query(__MODULE__, query)
-      def shape(query), do: Connection.shape(__MODULE__, query)
-      def write(quad),  do: Connection.write(__MODULE__, quad)
+      def child_spec, do: Pool.Spec.spec(__MODULE__)
+      def config,     do: Config.config(@otp_app, __MODULE__)
+
+      def delete(quad), do: send { :delete, quad }
+      def query(query), do: send { :query, query }
+      def shape(query), do: send { :shape, query }
+      def write(quad),  do: send { :write, quad }
+
+      defp send(request) do
+        :poolboy.transaction(__pool__, &GenServer.call(&1, request))
+      end
     end
   end
 
@@ -42,17 +50,17 @@ defmodule Caylir.Graph do
   @type t_write :: :ok | { :error, String.t }
 
   @doc """
-  Returns the child specification to start and supervise the graph connection.
+  Returns the (internal) pool module.
   """
-  defcallback child_spec :: Supervisor.Spec.spec
+  defcallback __pool__ :: module
 
   @doc """
-  Should return the configuration options used to communicate with the graph.
-
-  Needed parameters:
+  Returns a supervisable pool child_spec.
+  """
+  defcallback child_spec :: Supervisor.Spec.spec
 
-  - host
-  - port
+  @doc """
+  Returns the connection configuration.
   """
   defcallback config :: Keyword.t
 

lib/caylir/graph/connection/config.ex renamed to lib/caylir/graph/config.ex

@@ -1,4 +1,4 @@
-defmodule Caylir.Graph.Connection.Config do
+defmodule Caylir.Graph.Config do
   @moduledoc """
   Configuration helper module.
   """

lib/caylir/graph/connection.ex

@@ -0,0 +1,36 @@
+defmodule Caylir.Graph.Pool.Spec do
+  @moduledoc """
+  Connection pool specification helper.
+  """
+
+  alias Caylir.Graph.Pool
+
+  @doc """
+  Returns a supervisable pool child_spec.
+  """
+  @spec spec(conn :: module) :: Supervisor.Spec.spec
+  def spec(conn) do
+    { pool_opts, worker_opts } = get_opts(conn)
+
+    :poolboy.child_spec(conn, pool_opts, worker_opts)
+  end
+
+  defp get_opts(conn) do
+    { pool_opts,
+      worker_opts } = Keyword.split(conn.config, [ :size, :max_overflow ])
+
+    pool_opts =
+         pool_opts
+      |> Keyword.put_new(:max_overflow, 10)
+      |> Keyword.put_new(:size, 5)
+
+    pool_opts =
+         pool_opts
+      |> Keyword.put(:name, { :local, conn.__pool__ })
+      |> Keyword.put(:worker_module, Pool.Worker)
+
+    worker_opts = worker_opts |> Keyword.put(:module, conn)
+
+    { pool_opts, worker_opts }
+  end
+end

lib/caylir/graph/pool/spec.ex

@@ -0,0 +1,46 @@
+defmodule Caylir.Graph.Pool.Worker do
+  @moduledoc """
+  Pool worker.
+  """
+
+  alias Caylir.Graph.Request
+
+  @behaviour :poolboy_worker
+
+  @doc """
+  Starts the worker process.
+  """
+  @spec start_link(conn :: Keyword.t) :: GenServer.on_start
+  def start_link(conn) do
+    GenServer.start_link(__MODULE__, conn)
+  end
+
+  @doc """
+  Initializes the worker.
+  """
+  @spec init(conn :: Keyword.t) :: { :ok, Keyword.t }
+  def init(conn), do: { :ok, conn }
+
+
+  # GenServer callbacks
+
+  @doc false
+  def handle_call({ :delete, quad }, _from, conn) do
+    { :reply, Request.delete(quad, conn), conn }
+  end
+
+  @doc false
+  def handle_call({ :query, query }, _from, conn) do
+    { :reply, Request.query(query, conn), conn }
+  end
+
+  @doc false
+  def handle_call({ :shape, query }, _from, conn) do
+    { :reply, Request.shape(query, conn), conn }
+  end
+
+  @doc false
+  def handle_call({ :write, quad }, _from, conn) do
+    { :reply, Request.write(quad, conn), conn }
+  end
+end

lib/caylir/graph/pool/worker.ex

@@ -3,11 +3,67 @@ defmodule Caylir.Graph.Request do
   Sends requests to the server.
   """
 
+  alias Caylir.Graph
+
+  @doc """
+  Deletes a quad from the graph.
+  """
+  @spec delete(Keyword.t, Keyword.t) :: Graph.t_delete
+  def delete(quad, conn) do
+    url  = Graph.URL.delete(conn)
+    body = [ quad ] |> Poison.encode!
+
+    case send(:post, url, body) do
+      { :ok, 200, _success }          -> :ok
+      { :ok, 400, %{ error: reason }} -> { :error, reason }
+    end
+  end
+
+  @doc """
+  Queries the graph.
+  """
+  @spec query(String.t, Keyword.t) :: Graph.t_query
+  def query(query, conn) do
+    url = Graph.URL.query(conn)
+
+    case send(:post, url, query) do
+      { :ok, 200, %{ result: result }} -> result
+      { :ok, 400, %{ error:  reason }} -> { :error, reason }
+    end
+  end
+
+
   @doc """
-  Send a request to the server.
+  Gets the shape of a query.
   """
-  @spec send({ atom, String.t, String.t }) :: any
-  def send({ method, url, payload }) do
+  @spec shape(String.t, Keyword.t) :: Graph.t_query
+  def shape(query, conn) do
+    url = Graph.URL.shape(conn)
+
+    case send(:post, url, query) do
+      { :ok, 200, shape }             -> shape
+      { :ok, 400, %{ error: reason }} -> { :error, reason }
+    end
+  end
+
+  @doc """
+  Writes a quad to the graph.
+  """
+  @spec write(Keyword.t, Keyword.t) :: Graph.t_write
+  def write(quad, conn) do
+    url  = Graph.URL.write(conn)
+    body = [ quad ] |> Poison.encode!
+
+    case send(:post, url, body) do
+      { :ok, 200, _success }          -> :ok
+      { :ok, 400, %{ error: reason }} -> { :error, reason }
+    end
+  end
+
+
+  # Utility methods
+
+  defp send(method, url, payload) do
     body    = payload |> :binary.bin_to_list()
     headers = [{ 'Content-Type',  'application/x-www-form-urlencoded' },
                { 'Content-Length', length(body) }]
@@ -18,7 +74,6 @@ defmodule Caylir.Graph.Request do
     parse_response(status, response)
   end
 
-
   defp parse_response(status, ''),  do: { :ok, status }
   defp parse_response(status, body) do
     { :ok, status, Poison.decode!(body, keys: :atoms) }