initial commit

Author: hex2f

Diff for: .gitignore

@@ -0,0 +1,3 @@
+package.json
+package-lock.json
+node_modules/

Diff for: README.md

@@ -0,0 +1,3 @@
+# hooked.sh - WebSockets over HTTP
+
+hooked.sh lets you connect to WebSockets from your serverless apps by forwarding events over regular HTTP calls to your application.

Diff for: callbacktest.js

@@ -0,0 +1,15 @@
+var http = require('http')
+http.createServer(function (req, res) {
+  if (req.method.toLowerCase() == 'post') {
+    let data = ''
+    req.on('data', chunk => {
+      data += chunk
+    })
+    req.on('end', () => {
+      console.log("POST - " + data)
+      res.end()
+    });
+  } else {
+    res.end()
+  }
+}).listen(8009)

Diff for: js/lib/index.js

@@ -0,0 +1 @@
+throw new Error("This package is currently just a placeholder. Stay tuned https://hooked.sh/")

Diff for: server/.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

Diff for: server/.gitignore

@@ -0,0 +1,26 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+hooked-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/

Diff for: server/README.md

@@ -0,0 +1,21 @@
+# Hooked
+
+**TODO: Add description**
+
+## Installation
+
+If [available in Hex](https://hex.pm/docs/publish), the package can be installed
+by adding `hooked` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:hooked, "~> 0.1.0"}
+  ]
+end
+```
+
+Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
+and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
+be found at <https://hexdocs.pm/hooked>.
+

Diff for: server/lib/hooked.ex

@@ -0,0 +1,18 @@
+defmodule Hooked do
+  @moduledoc """
+  Documentation for `Hooked`.
+  """
+
+  @doc """
+  Hello world.
+
+  ## Examples
+
+      iex> Hooked.hello()
+      :world
+
+  """
+  def hello do
+    :world
+  end
+end

Diff for: server/lib/hooked/application.ex

@@ -0,0 +1,23 @@
+defmodule Hooked.Application do
+  # See https://hexdocs.pm/elixir/Application.html
+  # for more information on OTP Applications
+  @moduledoc false
+
+  use Application
+
+  @impl true
+  def start(_type, _args) do
+    children = [
+      {Bandit, scheme: :http, plug: Hooked.Router, options: [port: 8080]},
+      {Redix, host: "0.0.0.0", port: 56379, name: :redix},
+      {Registry, keys: :unique, name: :ws_registry},
+      {Finch, name: :callback_finch},
+      {DynamicSupervisor, strategy: :one_for_one, name: Hooked.WSSupervisor}
+    ]
+
+    # See https://hexdocs.pm/elixir/Supervisor.html
+    # for other strategies and supported options
+    opts = [strategy: :one_for_one, name: Hooked.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+end

Diff for: server/lib/hooked/authentication.ex

@@ -0,0 +1,26 @@
+defmodule Hooked.Authentication do
+  def validate_bearer_header(header_value_array) when is_list(header_value_array) do
+    do_validate_bearer_header(header_value_array)
+  end
+
+  # any amount of items left
+  defp do_validate_bearer_header([first_item | rest]) do
+    case first_item
+         |> String.split(" ") do
+      ["Bearer", token] ->
+        {:ok, uid} = Redix.command(:redix, ["GET", "bearer:#{token}"])
+        if uid == nil do
+          # {:error, :not_found}
+          {:ok, token, "none"}
+        else
+          {:ok, token, uid}
+        end
+
+      _ ->
+        do_validate_bearer_header(rest)
+    end
+  end
+
+  # no items left
+  defp do_validate_bearer_header([]), do: {:error, :not_found}
+end

Diff for: server/lib/hooked/router.ex

@@ -0,0 +1,94 @@
+defmodule Hooked.Router do
+  use Plug.Router
+
+  plug(:match)
+  plug(Plug.Parsers, parsers: [:json], pass: ["application/json"], json_decoder: Jason)
+  plug(:dispatch)
+
+  # get "/" do
+  #   conn
+  #   |> handle_extract_auth(fn (token) ->
+  #     {:ok, pong} = Redix.command(:redix, ["PING"])
+  #     {:ok, %{pong: pong}}
+  #   end)
+  #   |> handle_response(conn)
+  # end
+
+  post "/" do
+    conn
+    |> handle_extract_auth(&Hooked.WSConnection.start(conn, &1, &2))
+    |> handle_response(conn)
+  end
+
+  get "/:cid" do
+    conn
+    |> handle_extract_auth(fn _, _ -> Hooked.WSConnection.info(conn) end)
+    |> handle_response(conn)
+  end
+
+  post "/:cid" do
+    conn
+    |> handle_extract_auth(fn _, _ -> Hooked.WSConnection.send(conn) end)
+    |> handle_response(conn)
+  end
+
+  delete "/:cid" do
+    conn
+    |> handle_extract_auth(fn _, _ -> Hooked.WSConnection.stop(conn) end)
+    |> handle_response(conn)
+  end
+
+  match _ do
+    conn
+    |> put_resp_header("location", "https://dash.hooked.sh/")
+    |> send_resp(302, "https://dash.hooked.sh/")
+  end
+
+  defp handle_extract_auth(conn, success_lambda) do
+    case conn
+         |> get_req_header("authorization")
+         |> Hooked.Authentication.validate_bearer_header() do
+      {:ok, token, uid} ->
+        success_lambda.(token, uid)
+
+      {:error, _} ->
+        {:malformed_data, "Missing/Invalid authorization header"}
+    end
+  end
+
+  defp handle_response(response, conn) do
+    %{code: code, message: message, json: json} =
+      case response do
+        {:ok, data} ->
+          %{code: 200, message: Jason.encode!(data), json: true}
+
+        {:not_found, message} ->
+          %{code: 404, message: Jason.encode!(%{reason: message}), json: true}
+
+        {:conflict, message} ->
+          %{code: 409, message: Jason.encode!(%{reason: message}), json: true}
+
+        {:malformed_data, message} ->
+          %{code: 400, message: Jason.encode!(%{reason: message}), json: true}
+
+        {:not_authorized, message} ->
+          %{code: 401, message: Jason.encode!(%{reason: message}), json: true}
+
+        {:server_error, _} ->
+          %{code: 500, message: Jason.encode!(%{reason: "An error occurred internally"}), json: true}
+
+        _ ->
+          %{code: 500, message: Jason.encode!(%{reason: "An error occurred internally"}), json: true}
+      end
+
+    case json do
+      true ->
+        conn
+        |> put_resp_header("content-type", "application/json")
+
+      false ->
+        conn
+    end
+    |> send_resp(code, message)
+  end
+end

Diff for: server/lib/hooked/ws_connection.ex

@@ -0,0 +1,106 @@
+defmodule Hooked.WSConnection do
+  use WebSockex, restart: :temporary
+
+  def start_link([url, state, cid]) do
+    WebSockex.start_link(url, __MODULE__, state, name: via_tuple(cid), handle_initial_conn_failure: true)
+  end
+
+  # registry lookup handler
+  defp via_tuple(cid), do: {:via, Registry, {:ws_registry, cid}}
+
+  def handle_frame({:text, msg}, state) do
+    Redix.command(:redix, ["INCR", "usage:#{state.uid}:#{DateTime.utc_now.month}"])
+    Finch.build(:post, state.callback, [], msg) |> Finch.request(:callback_finch)
+    {:ok, state}
+  end
+
+  def handle_cast({:send, frame}, state) do
+    Redix.command(:redix, ["INCR", "usage:#{state.uid}:#{DateTime.utc_now.month}"])
+    {:reply, frame, state}
+  end
+
+  def handle_disconnect(_, state) do
+    IO.puts("dc")
+    :timer.sleep(15000)
+    {:reconnect, state}
+  end
+
+  def handle_info(:close_socket, {t_ref, state}) do
+    IO.puts("close socket")
+    :timer.cancel(t_ref)
+    {:close, {nil, state}}
+  end
+
+  defp not_nil(val, reason) do
+    if val != nil and val != "" do
+      {:ok, val}
+    else
+      {:error, reason}
+    end
+  end
+
+  defp expect_nil(val, reason) do
+    if val != nil do
+      {:error, reason}
+    else
+      {:ok, val}
+    end
+  end
+
+  def start_child(spec) do
+    {status, _} = DynamicSupervisor.start_child(Hooked.WSSupervisor, spec)
+    if status == :ok do
+      {:ok}
+    else
+      {:server_error, "Failed to connect"}
+    end
+  end
+
+  def start(conn, token, uid) do
+    with {:ok, url}      <- not_nil(Map.get(conn.body_params, "url"), {:malformed_data, "'url' needs to be provided in the JSON encoded body."}),
+         {:ok, callback} <- not_nil(Map.get(conn.body_params, "callback"), {:malformed_data, "'callback' needs to be provided in the JSON encoded body."}),
+         cid             <- Base.encode16(:crypto.hash(:sha256, "#{url}#{callback}#{token}")),
+         {:ok, _}        <- expect_nil(whereis(cid), {:conflict, "Connection between this websocket and callback is already open."}),
+         spec            <- {Hooked.WSConnection, [url, %{uid: uid, callback: callback}, cid]},
+         {:ok}           <- start_child(spec) do
+        {:ok, %{cid: cid}}
+      else
+        {:error, reason} -> reason
+      end
+  end
+
+  def stop(conn) do
+    with {:ok, cid} <- not_nil(Map.get(conn.path_params, "cid"), {:malformed_data, "'cid' is not specified in the url. Expected '/:cid'"}),
+         {:ok, pid} <- not_nil(whereis(cid), {:not_found, "This connection does not exist."}) do
+      Process.exit(pid, :kill)
+      {:ok, %{}}
+    else
+      {:error, reason} -> reason
+    end
+  end
+
+  def info(conn) do
+    with {:ok, cid} <- not_nil(Map.get(conn.path_params, "cid"), {:malformed_data, "'cid' is not specified in the url. Expected '/:cid'"}),
+         {:ok, pid} <- not_nil(whereis(cid), {:not_found, "This connection does not exist."}) do
+      {:ok, %{cid: cid}}
+    else
+      {:error, reason} -> reason
+    end
+  end
+
+  def send(conn) do
+    with {:ok, cid} <- not_nil(Map.get(conn.path_params, "cid"), {:malformed_data, "'cid' is not specified in the url. Expected '/:cid'"}),
+         {:ok, pid} <- not_nil(whereis(cid), {:not_found, "This connection does not exist."}) do
+      {:not_authorized, "TODO: Not Implemented Yet"}
+    else
+      {:error, reason} -> reason
+    end
+  end
+
+  def whereis(cid) do
+    case Registry.lookup(:ws_registry, cid) do
+      [{pid, _}] -> pid
+      [] -> nil
+    end
+  end
+end

Diff for: server/mix.exs

@@ -0,0 +1,32 @@
+defmodule Hooked.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :hooked,
+      version: "0.1.0",
+      elixir: "~> 1.13",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger],
+      mod: {Hooked.Application, []}
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      {:websockex, "~> 0.4.3"},
+      {:redix, "~> 1.1"},
+      {:bandit, ">= 0.5.0"},
+      {:jason, "~> 1.3"},
+      {:finch, "~> 0.12"}
+    ]
+  end
+end