├── assets
├── static
│ ├── favicon.ico
│ ├── images
│ │ └── phoenix.png
│ └── robots.txt
├── package.json
├── js
│ ├── app.js
│ ├── components
│ │ └── todo
│ │ │ ├── todo-new.js
│ │ │ ├── todo-item.js
│ │ │ └── index.js
│ └── socket.js
├── css
│ ├── app.scss
│ └── phoenix.css
└── brunch-config.js
├── lib
├── ztd_web
│ ├── views
│ │ ├── todo_view.ex
│ │ ├── layout_view.ex
│ │ ├── error_view.ex
│ │ └── error_helpers.ex
│ ├── templates
│ │ ├── todo
│ │ │ └── index.html.eex
│ │ └── layout
│ │ │ └── app.html.eex
│ ├── controllers
│ │ └── todo_controller.ex
│ ├── router.ex
│ ├── gettext.ex
│ ├── channels
│ │ ├── sockets_main.ex
│ │ └── todo_events.ex
│ └── endpoint.ex
├── ztd.ex
├── ztd
│ ├── repo
│ │ ├── repo.ex
│ │ └── schema.ex
│ ├── todo
│ │ ├── engine
│ │ │ ├── schema.ex
│ │ │ ├── engine.ex
│ │ │ ├── broadcaster.ex
│ │ │ └── listener.ex
│ │ ├── worker
│ │ │ ├── worker.ex
│ │ │ ├── dispatcher.ex
│ │ │ ├── rpc.ex
│ │ │ └── listener.ex
│ │ ├── todo.ex
│ │ ├── event.ex
│ │ ├── config.ex
│ │ └── supervisor.ex
│ └── application.ex
└── ztd_web.ex
├── test
├── test_helper.exs
├── ztd_web
│ ├── views
│ │ └── error_test.exs
│ ├── controllers
│ │ └── todo_test.exs
│ └── channels
│ │ └── todo_events_test.exs
├── support
│ ├── cases
│ │ ├── case.ex
│ │ ├── channel_case.ex
│ │ └── conn_case.ex
│ └── support.ex
└── ztd
│ └── todo
│ ├── event_test.exs
│ ├── engine_test.exs
│ └── config_test.exs
├── .travis.yml
├── Procfile
├── priv
├── repo
│ ├── seeds.exs
│ └── migrations
│ │ └── 20180610101141_create_todo_items.exs
└── gettext
│ ├── en
│ └── LC_MESSAGES
│ │ └── errors.po
│ └── errors.pot
├── config
├── test.exs
├── config.exs
├── dev.exs
└── prod.exs
├── .gitignore
├── .iex.exs
├── LICENSE
├── mix.exs
├── README.md
└── mix.lock
/assets/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sheharyarn/ztd/HEAD/assets/static/favicon.ico
--------------------------------------------------------------------------------
/lib/ztd_web/views/todo_view.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Views.Todo do
2 | use ZTD.Web, :view
3 | end
4 |
--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 |
3 | Ecto.Adapters.SQL.Sandbox.mode(ZTD.Repo, :manual)
4 |
5 |
--------------------------------------------------------------------------------
/assets/static/images/phoenix.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sheharyarn/ztd/HEAD/assets/static/images/phoenix.png
--------------------------------------------------------------------------------
/lib/ztd_web/templates/todo/index.html.eex:
--------------------------------------------------------------------------------
1 |
2 | <%= React.react_component("Components.Todo", %{items: @items, mode: @mode}) %>
3 |
4 |
--------------------------------------------------------------------------------
/lib/ztd_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Views.Layout do
2 | use ZTD.Web, :view
3 |
4 |
5 | def title do
6 | "ZTD Todo App"
7 | end
8 |
9 | end
10 |
--------------------------------------------------------------------------------
/assets/static/robots.txt:
--------------------------------------------------------------------------------
1 | # See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
2 | #
3 | # To ban all spiders from the entire site uncomment the next two lines:
4 | # User-agent: *
5 | # Disallow: /
6 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: elixir
2 | elixir:
3 | - 1.6.0
4 | otp_release:
5 | - 20.0
6 | services:
7 | - rabbitmq
8 | sudo: false
9 | env:
10 | global:
11 | - HEX_HTTP_CONCURRENCY=1
12 | - HEX_HTTP_TIMEOUT=120
13 | script:
14 | - mix test
15 |
--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | engine: env PORT=4000 APP_MODE=engine mix phx.server
2 | worker_1: env PORT=5001 APP_MODE=worker mix phx.server
3 | worker_2: env PORT=5002 APP_MODE=worker mix phx.server
4 | worker_3: env PORT=5003 APP_MODE=worker mix phx.server
5 | worker_4: env PORT=5004 APP_MODE=worker mix phx.server
6 |
--------------------------------------------------------------------------------
/lib/ztd.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD do
2 | @moduledoc """
3 | ZTD keeps the contexts that define your domain
4 | and business logic.
5 |
6 | Contexts are also responsible for managing your data, regardless
7 | if it comes from the database, an external API or others.
8 | """
9 | end
10 |
--------------------------------------------------------------------------------
/lib/ztd/repo/repo.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Repo do
2 | use Ecto.Repo, otp_app: :ztd
3 |
4 | @doc """
5 | Dynamically loads the repository url from the
6 | DATABASE_URL environment variable.
7 | """
8 | def init(_, opts) do
9 | {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/lib/ztd_web/controllers/todo_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Controllers.Todo do
2 | use ZTD.Web, :controller
3 |
4 | alias ZTD.Todo
5 |
6 |
7 | @doc "GET: All Todo Items"
8 | def index(conn, _params) do
9 | render(conn, "index.html", items: Todo.all, mode: Todo.Config.mode)
10 | end
11 |
12 | end
13 |
--------------------------------------------------------------------------------
/priv/repo/seeds.exs:
--------------------------------------------------------------------------------
1 | # Script for populating the database. You can run it as:
2 | #
3 | # mix run priv/repo/seeds.exs
4 | #
5 | # Inside the script, you can read and write to any of your
6 | # repositories directly:
7 | #
8 | # ZTD.Repo.insert!(%ZTD.SomeSchema{})
9 | #
10 | # We recommend using the bang functions (`insert!`, `update!`
11 | # and so on) as they will fail if something goes wrong.
12 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20180610101141_create_todo_items.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Repo.Migrations.CreateTodoItems do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:todo_items, primary_key: false) do
6 | add :id, :binary_id, primary_key: true
7 | add :title, :string, null: false
8 | add :done, :boolean, null: false, default: false
9 |
10 | timestamps()
11 | end
12 | end
13 |
14 | end
15 |
--------------------------------------------------------------------------------
/test/ztd_web/views/error_test.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.ErrorViewTest do
2 | use ZTD.Tests.Support.ConnCase, async: true
3 | import Phoenix.View
4 |
5 |
6 | describe "Error Pages" do
7 | @view ZTD.Web.Views.Error
8 |
9 | test "renders 404.html" do
10 | assert render_to_string(@view, "404.html", []) == "Not Found"
11 | end
12 |
13 | test "renders 500.html" do
14 | assert render_to_string(@view, "500.html", []) == "Internal Server Error"
15 | end
16 | end
17 |
18 | end
19 |
--------------------------------------------------------------------------------
/test/support/cases/case.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Support.Case do
2 | use ExUnit.CaseTemplate
3 |
4 | @moduledoc """
5 | Default Test Case with important aliases/imports
6 | """
7 |
8 |
9 | using do
10 | quote do
11 | alias ZTD.Repo
12 | alias ZTD.Tests.Support
13 |
14 | alias Ecto.Query
15 | alias Ecto.Changeset
16 |
17 | require Query
18 | import Support.Schema
19 | end
20 | end
21 |
22 |
23 | setup tags do
24 | ZTD.Tests.Support.setup_ecto(tags)
25 | end
26 |
27 | end
28 |
--------------------------------------------------------------------------------
/lib/ztd/repo/schema.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Repo.Schema do
2 |
3 | @moduledoc """
4 | Custom Macro for initializing Schemas with
5 | sane defaults
6 | """
7 |
8 | defmacro __using__(_opts) do
9 | quote do
10 | use Ecto.Schema
11 | use Ecto.Rut, repo: ZTD.Repo
12 |
13 | @primary_key {:id, :binary_id, autogenerate: true}
14 | @foreign_key_type :binary_id
15 |
16 | import Ecto.Changeset
17 | require Ecto.Query
18 |
19 | alias Ecto.Query
20 | alias ZTD.Repo
21 | end
22 | end
23 |
24 | end
25 |
26 |
--------------------------------------------------------------------------------
/config/test.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 |
3 | # We don't run a server during test. If one is required,
4 | # you can enable the server option below.
5 | config :ztd, ZTD.Web.Endpoint,
6 | http: [port: 4001],
7 | server: false
8 |
9 | # Print only warnings and errors during test
10 | config :logger, level: :warn
11 |
12 | # Configure your database
13 | config :ztd, ZTD.Repo,
14 | adapter: Ecto.Adapters.Postgres,
15 | username: "postgres",
16 | password: "postgres",
17 | database: "ztd_test",
18 | hostname: "localhost",
19 | pool: Ecto.Adapters.SQL.Sandbox
20 |
--------------------------------------------------------------------------------
/lib/ztd_web/views/error_view.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Views.Error do
2 | use ZTD.Web, :view
3 |
4 | # If you want to customize a particular status code
5 | # for a certain format, you may uncomment below.
6 | # def render("500.html", _assigns) do
7 | # "Internal Server Error"
8 | # end
9 |
10 | # By default, Phoenix returns the status message from
11 | # the template name. For example, "404.html" becomes
12 | # "Not Found".
13 | def template_not_found(template, _assigns) do
14 | Phoenix.Controller.status_message_from_template(template)
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/lib/ztd_web/router.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Router do
2 | use ZTD.Web, :router
3 |
4 |
5 | # Pipelines
6 | # ---------
7 |
8 | pipeline :browser do
9 | plug :accepts, ["html"]
10 | plug :fetch_session
11 | plug :fetch_flash
12 | plug :protect_from_forgery
13 | plug :put_secure_browser_headers
14 | end
15 |
16 | pipeline :api do
17 | plug :accepts, ["json"]
18 | end
19 |
20 |
21 |
22 | # Routes
23 | # ------
24 |
25 | scope "/", ZTD.Web.Controllers do
26 | pipe_through :browser
27 |
28 | get "/", Todo, :index
29 | end
30 |
31 |
32 | end
33 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # App artifacts
2 | /_build
3 | /db
4 | /deps
5 | /*.ez
6 |
7 | # Generated on crash by the VM
8 | erl_crash.dump
9 |
10 | # Generated on crash by NPM
11 | npm-debug.log
12 |
13 | # Static artifacts
14 | /assets/node_modules
15 |
16 | # Since we are building assets from assets/,
17 | # we ignore priv/static. You may want to comment
18 | # this depending on your deployment strategy.
19 | /priv/static/
20 |
21 | # Files matching config/*.secret.exs pattern contain sensitive
22 | # data and you should not commit them into version control.
23 | #
24 | # Alternatively, you may comment the line below and commit the
25 | # secrets files as long as you replace their contents by environment
26 | # variables.
27 | /config/*.secret.exs
--------------------------------------------------------------------------------
/lib/ztd/todo/engine/schema.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Engine.Schema do
2 | use ZTD.Repo.Schema
3 |
4 |
5 |
6 | ## Schema
7 | ## ------
8 |
9 | @fields_required [:title]
10 | @fields_optional [:done]
11 | @fields_all (@fields_optional ++ @fields_required)
12 | @derive {Poison.Encoder, only: [:id | @fields_all]}
13 |
14 |
15 | schema "todo_items" do
16 | field :title, :string
17 | field :done, :boolean, default: false
18 |
19 | timestamps()
20 | end
21 |
22 |
23 |
24 |
25 | ## Public API
26 | ## ----------
27 |
28 |
29 | @doc "Create Changeset"
30 | def changeset(struct, attrs) do
31 | struct
32 | |> cast(attrs, @fields_all)
33 | |> validate_required(@fields_required)
34 | end
35 |
36 | end
37 |
--------------------------------------------------------------------------------
/assets/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "repository": {},
3 | "license": "MIT",
4 | "scripts": {
5 | "deploy": "brunch build --production",
6 | "watch": "brunch watch --stdin"
7 | },
8 | "dependencies": {
9 | "babel-preset-env": "^1.7.0",
10 | "babel-preset-react": "^6.24.1",
11 | "lodash": "^4.17.10",
12 | "phoenix": "file:../deps/phoenix",
13 | "phoenix_html": "file:../deps/phoenix_html",
14 | "react": "^16.4.0",
15 | "react-dom": "^16.2.0",
16 | "react-phoenix": "file:../deps/react_phoenix",
17 | "sass-brunch": "^2.10.4"
18 | },
19 | "devDependencies": {
20 | "babel-brunch": "6.1.1",
21 | "brunch": "2.10.9",
22 | "clean-css-brunch": "2.10.0",
23 | "uglify-js-brunch": "2.10.0"
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/lib/ztd/application.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Application do
2 | use Application
3 |
4 |
5 | @doc "Start application supervision tree"
6 | def start(_type, _args) do
7 | import Supervisor.Spec
8 |
9 | children = [
10 | # Todo Sub App
11 | supervisor(ZTD.Todo.Supervisor, []),
12 |
13 | # Web Server
14 | supervisor(ZTD.Web.Endpoint, []),
15 | ]
16 |
17 | opts = [strategy: :one_for_one, name: ZTD.Supervisor]
18 | Supervisor.start_link(children, opts)
19 | end
20 |
21 |
22 | # Tell Phoenix to update the endpoint configuration
23 | # whenever the application is updated.
24 | def config_change(changed, _new, removed) do
25 | ZTD.Web.Endpoint.config_change(changed, removed)
26 | :ok
27 | end
28 |
29 | end
30 |
--------------------------------------------------------------------------------
/lib/ztd_web/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Gettext do
2 | @moduledoc """
3 | A module providing Internationalization with a gettext-based API.
4 |
5 | By using [Gettext](https://hexdocs.pm/gettext),
6 | your module gains a set of macros for translations, for example:
7 |
8 | import ZTD.Web.Gettext
9 |
10 | # Simple translation
11 | gettext "Here is the string to translate"
12 |
13 | # Plural translation
14 | ngettext "Here is the string to translate",
15 | "Here are the strings to translate",
16 | 3
17 |
18 | # Domain-based translation
19 | dgettext "errors", "Here is the error message to translate"
20 |
21 | See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 | """
23 | use Gettext, otp_app: :ztd
24 | end
25 |
--------------------------------------------------------------------------------
/.iex.exs:
--------------------------------------------------------------------------------
1 | alias ZTD.{Todo, Todo.Config, Todo.Engine, Todo.Worker}
2 | alias ZTD.{Web, Web.Channels.TodoEvents}
3 | alias ZTD.Repo
4 | alias Ecto.Query
5 |
6 | require Query
7 |
8 |
9 | request_queue = Config.get(:amqp)[:request_queue]
10 | request_exchange = Config.get(:amqp)[:request_exchange]
11 | broadcast_exchange = Config.get(:amqp)[:broadcast_exchange]
12 |
13 |
14 | engine_channel = fn ->
15 | {:ok, connection} = AMQP.Connection.open
16 | {:ok, channel} = AMQP.Channel.open(connection)
17 |
18 | AMQP.Exchange.declare(channel, request_exchange, :direct)
19 | AMQP.Queue.declare(channel, request_queue, durable: false)
20 | AMQP.Queue.bind(channel, request_queue, request_exchange)
21 |
22 | channel
23 | end
24 |
25 | engine_publish = fn channel, message ->
26 | AMQP.Basic.publish(channel, request_exchange, request_queue, message)
27 | end
28 |
29 |
--------------------------------------------------------------------------------
/assets/js/app.js:
--------------------------------------------------------------------------------
1 | // Brunch automatically concatenates all files in your
2 | // watched paths. Those paths can be configured at
3 | // config.paths.watched in "brunch-config.js".
4 | //
5 | // However, those files will only be executed if
6 | // explicitly imported. The only exception are files
7 | // in vendor, which are never wrapped in imports and
8 | // therefore are always executed.
9 |
10 | // Import dependencies
11 | //
12 | // If you no longer want to use a dependency, remember
13 | // to also remove its path from "config.paths.watched".
14 | import "phoenix_html"
15 | import "react-phoenix"
16 |
17 | // Import local files
18 | //
19 | // Local files can be imported directly using relative
20 | // paths "./socket" or full ones "web/static/js/socket".
21 |
22 | // import socket from "./socket"
23 |
24 |
25 | // React Components
26 | import Todo from "./components/todo"
27 |
28 | window.Components = {
29 | Todo,
30 | };
31 |
--------------------------------------------------------------------------------
/lib/ztd/todo/worker/worker.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Worker do
2 | alias ZTD.Todo.Event
3 | alias ZTD.Todo.Worker.RPC
4 | alias ZTD.Todo.Worker.Dispatcher
5 |
6 |
7 | @moduledoc """
8 | Worker implementation for the Todo interface.
9 | Implements all methods defined in the Todo module.
10 |
11 | Each action is wrapped in an event and dispatched
12 | to the engine.
13 | """
14 |
15 |
16 |
17 | @doc "Get all todos"
18 | def all do
19 | RPC.all
20 | end
21 |
22 |
23 | @doc "Insert new todo"
24 | def insert(%{} = params) do
25 | :insert
26 | |> Event.new(params)
27 | |> Dispatcher.send!
28 | end
29 |
30 |
31 | @doc "Update a todo"
32 | def update(id, %{} = params) do
33 | data = Map.put(params, :id, id)
34 |
35 | :update
36 | |> Event.new(data)
37 | |> Dispatcher.send!
38 | end
39 |
40 |
41 | @doc "Delete a todo"
42 | def delete(id) do
43 | :delete
44 | |> Event.new(%{id: id})
45 | |> Dispatcher.send!
46 | end
47 |
48 | end
49 |
--------------------------------------------------------------------------------
/lib/ztd/todo/todo.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo do
2 | import ZTD.Todo.Config, only: [adapter: 0]
3 |
4 |
5 | @moduledoc """
6 | Provides an interface to add, update, delete and
7 | mark items done/undone. Selects the correct adapter
8 | and delegates the method call to it.
9 |
10 | NOTE:
11 | If the application grows complex in the future, it
12 | would make sense to turn this into a behaviour and
13 | define a __using__ macro which implements it and
14 | verifies if all callbacks have been implemented.
15 | """
16 |
17 |
18 |
19 |
20 | @doc "Get all todos"
21 | def all do
22 | adapter().all()
23 | end
24 |
25 |
26 |
27 | @doc "Insert new todo"
28 | def insert(%{} = params) do
29 | adapter().insert(params)
30 | end
31 |
32 |
33 |
34 | @doc "Update a todo"
35 | def update(id, %{} = params) do
36 | adapter().update(id, params)
37 | end
38 |
39 |
40 |
41 | @doc "Delete a todo"
42 | def delete(id) do
43 | adapter().delete(id)
44 | end
45 |
46 |
47 | end
48 |
--------------------------------------------------------------------------------
/test/support/cases/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Support.ChannelCase do
2 | use ExUnit.CaseTemplate
3 |
4 | @moduledoc """
5 | This module defines the test case to be used by
6 | channel tests.
7 |
8 | Such tests rely on `Phoenix.ChannelTest` and also
9 | import other functionality to make it easier
10 | to build common datastructures and query the data layer.
11 |
12 | Finally, if the test case interacts with the database,
13 | it cannot be async. For this reason, every test runs
14 | inside a transaction which is reset at the beginning
15 | of the test unless the test case is marked as async.
16 | """
17 |
18 |
19 | using do
20 | quote do
21 | # Import conveniences for testing with channels
22 | use Phoenix.ChannelTest
23 |
24 | alias ZTD.Tests.Support
25 |
26 | # The default endpoint for testing
27 | @endpoint ZTD.Web.Endpoint
28 | end
29 | end
30 |
31 |
32 | setup tags do
33 | ZTD.Tests.Support.setup_ecto(tags)
34 | end
35 |
36 | end
37 |
--------------------------------------------------------------------------------
/lib/ztd_web/templates/layout/app.html.eex:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | <%= title() %>
11 |
16 |
19 |
20 |
<%= get_flash(@conn, :info) %>
21 |
<%= get_flash(@conn, :error) %>
22 |
23 |
24 | <%= render @view_module, @view_template, assigns %>
25 |
26 |
27 |
37 |
45 | );
46 | }
47 | }
48 |
49 |
50 |
51 | // Prop Specification
52 | TodoNew.propTypes = {
53 | broadcast: PropTypes.func.isRequired,
54 | };
55 |
56 |
57 |
58 | // Export
59 | export default TodoNew;
60 |
--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 |
3 |
4 | # General Application Config
5 | config :ztd,
6 | namespace: ZTD,
7 | ecto_repos: [ZTD.Repo],
8 | generators: [binary_id: true]
9 |
10 |
11 | # Todo Settings / Mode Adapters
12 | config :ztd, :todo,
13 | env_var: "APP_MODE",
14 | default: :engine,
15 | adapters: [
16 | engine: ZTD.Todo.Engine,
17 | worker: ZTD.Todo.Worker,
18 | ],
19 | amqp: [
20 | request_queue: "ztd.todo.requests.queue",
21 | request_exchange: "ztd.todo.requests.exchange",
22 | broadcast_exchange: "ztd.todo.broadcasts.exchange",
23 | broadcast_routing: "ztd.todo.broadcasts.routing",
24 | ]
25 |
26 |
27 | # Endpoint
28 | config :ztd, ZTD.Web.Endpoint,
29 | url: [host: "localhost"],
30 | secret_key_base: "Q6jgvP5PBpizrwNmRpmL+jufEpjbTV9JjEH+FC6HngbYlk2EThFD2CHKSAZ85jOy",
31 | render_errors: [view: ZTD.Web.ErrorView, accepts: ~w(html json)],
32 | pubsub: [name: ZTD.PubSub, adapter: Phoenix.PubSub.PG2]
33 |
34 |
35 | # Logger
36 | config :logger, :console,
37 | format: "$time $metadata[$level] $message\n",
38 | metadata: [:user_id]
39 |
40 |
41 | # Import environment specific config. This must remain at the bottom
42 | # of this file so it overrides the configuration defined above.
43 | import_config "#{Mix.env}.exs"
44 |
--------------------------------------------------------------------------------
/lib/ztd_web/channels/sockets_main.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Sockets.Main do
2 | use Phoenix.Socket
3 |
4 | ## Channels
5 | channel "todo_events", ZTD.Web.Channels.TodoEvents
6 |
7 | ## Transports
8 | transport :websocket, Phoenix.Transports.WebSocket
9 | # transport :longpoll, Phoenix.Transports.LongPoll
10 |
11 | # Socket params are passed from the client and can
12 | # be used to verify and authenticate a user. After
13 | # verification, you can put default assigns into
14 | # the socket that will be set for all channels, ie
15 | #
16 | # {:ok, assign(socket, :user_id, verified_user_id)}
17 | #
18 | # To deny connection, return `:error`.
19 | #
20 | # See `Phoenix.Token` documentation for examples in
21 | # performing token verification on connect.
22 | def connect(_params, socket) do
23 | {:ok, socket}
24 | end
25 |
26 | # Socket id's are topics that allow you to identify all sockets for a given user:
27 | #
28 | # def id(socket), do: "user_socket:#{socket.assigns.user_id}"
29 | #
30 | # Would allow you to broadcast a "disconnect" event and terminate
31 | # all active sockets and channels for a given user:
32 | #
33 | # ZTD.Web.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
34 | #
35 | # Returning `nil` makes this socket anonymous.
36 | def id(_socket), do: nil
37 | end
38 |
--------------------------------------------------------------------------------
/lib/ztd/todo/config.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Config do
2 | @moduledoc """
3 | Interface for getting Todo Configs
4 | """
5 |
6 | @app_name :ztd
7 | @config_key :todo
8 |
9 |
10 |
11 |
12 |
13 | ## Public API
14 | ## ----------
15 |
16 |
17 | @doc "Get Todo Config"
18 | def get do
19 | Application.get_env(@app_name, @config_key)
20 | end
21 |
22 |
23 | @doc "Get Todo config for a specific key"
24 | def get(key, default \\ nil) when is_atom(key) do
25 | get() |> Keyword.get(key, default)
26 | end
27 |
28 |
29 | @doc "Return the Application mode"
30 | def mode do
31 | mode =
32 | :env_var
33 | |> get()
34 | |> System.get_env
35 | |> normalize()
36 | |> fallback_to_default()
37 |
38 | case (mode in allowed_modes()) do
39 | true -> mode
40 | false -> raise "Unknown Application Mode"
41 | end
42 | end
43 |
44 |
45 | @doc "Return the correct adapter for config"
46 | def adapter do
47 | get(:adapters) |> Keyword.get(mode())
48 | end
49 |
50 |
51 |
52 |
53 |
54 | ## Private Helpers
55 | ## ---------------
56 |
57 |
58 | defp allowed_modes do
59 | Keyword.keys(get(:adapters))
60 | end
61 |
62 | defp normalize(str) do
63 | "#{str}"
64 | |> String.downcase
65 | |> String.to_existing_atom
66 | end
67 |
68 | defp fallback_to_default(mode) do
69 | case mode do
70 | mode when mode in ["", :"", nil] ->
71 | get(:default)
72 |
73 | mode -> mode
74 | end
75 | end
76 |
77 | end
78 |
--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Mixfile do
2 | use Mix.Project
3 |
4 |
5 | def project do
6 | [
7 | app: :ztd,
8 | version: "0.0.1",
9 | elixir: "~> 1.4",
10 | elixirc_paths: elixirc_paths(Mix.env),
11 | compilers: [:phoenix, :gettext] ++ Mix.compilers,
12 | start_permanent: Mix.env == :prod,
13 | aliases: aliases(),
14 | deps: deps()
15 | ]
16 | end
17 |
18 |
19 | def application do
20 | [
21 | mod: {ZTD.Application, []},
22 | extra_applications: [:logger, :runtime_tools]
23 | ]
24 | end
25 |
26 |
27 | defp elixirc_paths(:test), do: ["lib", "test/support"]
28 | defp elixirc_paths(_), do: ["lib"]
29 |
30 |
31 | defp deps do
32 | [
33 | {:phoenix, "~> 1.3.2"},
34 | {:phoenix_pubsub, "~> 1.0"},
35 | {:phoenix_ecto, "~> 3.2"},
36 | {:postgrex, ">= 0.0.0"},
37 | {:gettext, "~> 0.11"},
38 | {:cowboy, "~> 1.0"},
39 | {:phoenix_html, "~> 2.10"},
40 | {:phoenix_live_reload, "~> 1.0", only: :dev},
41 |
42 | {:ecto_rut, "~> 1.2.2"},
43 | {:better_params, "~> 0.5.0"},
44 | {:react_phoenix, "~> 0.5.2"},
45 | {:amqp, "~> 0.3.1"},
46 | ]
47 | end
48 |
49 |
50 | defp aliases do
51 | [
52 | "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
53 | "ecto.reset": ["ecto.drop", "ecto.setup"],
54 | "test": ["ecto.create --quiet", "ecto.migrate", "test"]
55 | ]
56 | end
57 | end
58 |
--------------------------------------------------------------------------------
/lib/ztd/todo/supervisor.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Supervisor do
2 | use Supervisor
3 |
4 | alias ZTD.Todo.Config
5 | import Supervisor.Spec
6 |
7 |
8 | @moduledoc """
9 | Manages the Todo Supervision Tree and starts the
10 | appropriate Mode Adapter (Engine/Worker) depending
11 | on the specified env config
12 |
13 | NOTE:
14 | If the application grows too complex, consider
15 | creating sub-supervisors for both Engine and Worker
16 | within their Adapters
17 | """
18 |
19 |
20 |
21 |
22 | ## Public API
23 | ## ----------
24 |
25 |
26 | @doc "Start the Todo Supervisor"
27 | def start_link do
28 | Supervisor.start_link(__MODULE__, :ok, name: __MODULE__)
29 | end
30 |
31 |
32 |
33 |
34 |
35 | ## Callbacks
36 | ## ---------
37 |
38 |
39 | def init(:ok) do
40 | Config.mode()
41 | |> children()
42 | |> Supervisor.init(strategy: :one_for_one)
43 | end
44 |
45 |
46 |
47 |
48 |
49 | ## Children Spec
50 | ## -------------
51 |
52 |
53 | # Children for Engine Mode
54 | defp children(:engine) do
55 | [
56 | supervisor(ZTD.Repo, []),
57 | worker(ZTD.Todo.Engine.Broadcaster, []),
58 | worker(ZTD.Todo.Engine.Listener, []),
59 | ]
60 | end
61 |
62 |
63 | # Children for Worker Mode
64 | defp children(:worker) do
65 | [
66 | worker(ZTD.Todo.Worker.Listener, []),
67 | worker(ZTD.Todo.Worker.Dispatcher, []),
68 | ]
69 | end
70 |
71 |
72 |
73 | # Raise error for other modes
74 | defp children(_mode) do
75 | raise "Supervision Tree not defined for specified mode"
76 | end
77 |
78 |
79 | end
80 |
--------------------------------------------------------------------------------
/lib/ztd/todo/engine/engine.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Engine do
2 | alias ZTD.Repo
3 | alias ZTD.Todo.Event
4 | alias ZTD.Todo.Engine.Schema
5 | alias ZTD.Todo.Engine.Broadcaster
6 | alias Ecto.Query
7 |
8 | require Query
9 |
10 |
11 | @moduledoc """
12 | Engine implementation for the Todo interface.
13 | Implements all methods defined in Todo module.
14 | """
15 |
16 |
17 |
18 | # Public API
19 | # ----------
20 |
21 |
22 | @doc "Get all todos"
23 | def all do
24 | Schema
25 | |> Query.order_by(asc: :inserted_at)
26 | |> Repo.all
27 | end
28 |
29 |
30 |
31 | @doc "Insert new todo"
32 | def insert(%{} = params) do
33 | params
34 | |> Schema.insert
35 | |> broadcast!(:insert)
36 | end
37 |
38 |
39 |
40 | @doc "Update a todo"
41 | def update(id, %{} = params) do
42 | id
43 | |> Schema.get!
44 | |> Schema.update(params)
45 | |> broadcast!(:update)
46 | end
47 |
48 |
49 |
50 | @doc """
51 | Delete a todo
52 |
53 | Using a where clause so it doesn't raise errors for
54 | stale structs
55 | """
56 | def delete(id) do
57 | Schema
58 | |> Query.where([i], i.id == ^id)
59 | |> Repo.delete_all
60 |
61 | broadcast!({:ok, %{id: id}}, :delete)
62 | end
63 |
64 |
65 |
66 |
67 |
68 | # Private Helpers
69 | # ---------------
70 |
71 |
72 | # Broadcast on success
73 | defp broadcast!({:ok, item} = term, type) do
74 | type
75 | |> Event.new(item)
76 | |> Broadcaster.broadcast!
77 |
78 | term
79 | end
80 |
81 | defp broadcast!(term, _type) do
82 | term
83 | end
84 |
85 |
86 | end
87 |
--------------------------------------------------------------------------------
/test/support/support.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Support do
2 | @moduledoc "Support methods for tests"
3 |
4 |
5 | @doc """
6 | Setup Ecto for each test
7 |
8 | If the test case interacts with the database, it cannot be async. For this
9 | reason, every test runs inside a transaction which is reset at the beginning
10 | of the test unless the test case is marked as async.
11 | """
12 | def setup_ecto(tags) do
13 | :ok = Ecto.Adapters.SQL.Sandbox.checkout(ZTD.Repo)
14 | unless tags[:async] do
15 | Ecto.Adapters.SQL.Sandbox.mode(ZTD.Repo, {:shared, self()})
16 | end
17 | :ok
18 | end
19 |
20 |
21 | @doc "Sleep / wait for something"
22 | def wait(ms \\ 5) do
23 | Process.sleep(ms)
24 | end
25 |
26 |
27 |
28 |
29 | defmodule Schema do
30 | @doc """
31 | A helper that transform changeset errors to a map of messages.
32 |
33 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
34 | assert "password is too short" in errors_on(changeset).password
35 | assert %{password: ["password is too short"]} = errors_on(changeset)
36 |
37 | """
38 | def errors_on(changeset) do
39 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
40 | Enum.reduce(opts, message, fn {key, value}, acc ->
41 | String.replace(acc, "%{#{key}}", to_string(value))
42 | end)
43 | end)
44 | end
45 |
46 |
47 | def error_message(changeset, field) do
48 | case changeset.errors[field] do
49 | {message, _} -> message
50 | _something -> nil
51 | end
52 | end
53 |
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/lib/ztd_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.ErrorHelpers do
2 | @moduledoc """
3 | Conveniences for translating and building error messages.
4 | """
5 |
6 | use Phoenix.HTML
7 |
8 | @doc """
9 | Generates tag for inlined form input errors.
10 | """
11 | def error_tag(form, field) do
12 | Enum.map(Keyword.get_values(form.errors, field), fn (error) ->
13 | content_tag :span, translate_error(error), class: "help-block"
14 | end)
15 | end
16 |
17 | @doc """
18 | Translates an error message using gettext.
19 | """
20 | def translate_error({msg, opts}) do
21 | # When using gettext, we typically pass the strings we want
22 | # to translate as a static argument:
23 | #
24 | # # Translate "is invalid" in the "errors" domain
25 | # dgettext "errors", "is invalid"
26 | #
27 | # # Translate the number of files with plural rules
28 | # dngettext "errors", "1 file", "%{count} files", count
29 | #
30 | # Because the error messages we show in our forms and APIs
31 | # are defined inside Ecto, we need to translate them dynamically.
32 | # This requires us to call the Gettext module passing our gettext
33 | # backend as first argument.
34 | #
35 | # Note we use the "errors" domain, which means translations
36 | # should be written to the errors.po file. The :count option is
37 | # set by Ecto and indicates we should also apply plural rules.
38 | if count = opts[:count] do
39 | Gettext.dngettext(ZTD.Web.Gettext, "errors", msg, msg, count, opts)
40 | else
41 | Gettext.dgettext(ZTD.Web.Gettext, "errors", msg, opts)
42 | end
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/test/ztd/todo/event_test.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Todo.Event do
2 | use ZTD.Tests.Support.Case, async: true
3 | alias ZTD.Todo.Event
4 |
5 |
6 |
7 | describe "new/2" do
8 | test "returns an Event struct for valid args" do
9 | assert %Event{type: :insert, data: %{}} = Event.new(:insert, %{})
10 | end
11 |
12 |
13 | test "raises error for invalid type" do
14 | assert_raise(Event.InvalidError, fn ->
15 | Event.new(:unknown_type, %{})
16 | end)
17 | end
18 | end
19 |
20 |
21 |
22 | describe "encode!/1" do
23 | setup do
24 | [event: Event.new(:insert, %{a: "X", b: "Y"})]
25 | end
26 |
27 | test "converts Event struct into json", %{event: event} do
28 | string = Event.encode!(event)
29 |
30 | assert string =~ ~r/"type":"insert"/
31 | assert string =~ ~r/"a":"X"/
32 | assert string =~ ~r/"b":"Y"/
33 | end
34 | end
35 |
36 |
37 |
38 | describe "decode!/1" do
39 | @string "1,2,3"
40 | test "raises error for invalidly formed json" do
41 | assert_raise(Event.InvalidError, fn ->
42 | Event.decode!(@string)
43 | end)
44 | end
45 |
46 |
47 | @string Event.encode!(%Event{type: :invalid, data: %{id: "123"}})
48 | test "raises error for invalid event json" do
49 | assert_raise(Event.InvalidError, fn ->
50 | Event.decode!(@string)
51 | end)
52 | end
53 |
54 |
55 | @string Event.encode!(%Event{type: :delete, data: %{id: "123"}})
56 | test "converts valid event json string back to event" do
57 | assert %{type: :delete, data: %{id: "123"}} = Event.decode!(@string)
58 | end
59 | end
60 |
61 | end
62 |
63 |
--------------------------------------------------------------------------------
/assets/css/app.scss:
--------------------------------------------------------------------------------
1 | /* This file is for your main application css. */
2 |
3 |
4 | /* Basic Layout
5 | * ************ */
6 |
7 | #ztd-app {
8 | max-width: 25em;
9 | margin: 1em auto;
10 | }
11 |
12 |
13 | header.header {
14 | margin-bottom: 12px;
15 |
16 | h1 {
17 | text-align: center;
18 | margin-bottom: 20px;
19 | }
20 | }
21 |
22 |
23 |
24 |
25 |
26 | /* Todo Components
27 | * *************** */
28 |
29 | .todo-app .app-status {
30 | border-bottom: 1px solid #e5e5e5;
31 | margin-bottom: 30px;
32 | padding-bottom: 10px;
33 | font-size: 10px;
34 | text-align: center;
35 | text-transform: uppercase;
36 |
37 | span:not(:last-child) {
38 | margin-right: 15px;
39 | }
40 | }
41 |
42 |
43 | .todo-app .new-item {
44 | input {
45 | font-size: 1.5em;
46 | width: 100%;
47 | }
48 | }
49 |
50 | .todo-app .item-list {
51 | padding: 1em 2em;
52 | }
53 |
54 |
55 | .todo-app .item-list .item {
56 | font-size: 1.4em;
57 |
58 | .content {
59 | display: inline-block;
60 | width: 82%;
61 | border: none;
62 |
63 | &.is-done {
64 | color: #ccc;
65 | text-decoration: line-through;
66 | }
67 | }
68 |
69 | .status {
70 | display: inline-block;
71 | transform: scale(1.2);
72 | margin-right: 0.5em !important;
73 | }
74 |
75 | .delete {
76 | float: right;
77 | text-decoration: none;
78 | color: #777;
79 | margin-top: 1px;
80 | cursor: pointer;
81 | }
82 | }
83 |
84 |
85 | .todo-app .wall-holder {
86 | position: relative;
87 |
88 | .wall.active {
89 | position: absolute;
90 | background-color: rgba(#000000, 0.1);
91 | top: 0;
92 | left: 0;
93 | height: 100%;
94 | width: 100%;
95 | cursor: not-allowed;
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/assets/brunch-config.js:
--------------------------------------------------------------------------------
1 | exports.config = {
2 | // See http://brunch.io/#documentation for docs.
3 | files: {
4 | javascripts: {
5 | joinTo: "js/app.js"
6 |
7 | // To use a separate vendor.js bundle, specify two files path
8 | // http://brunch.io/docs/config#-files-
9 | // joinTo: {
10 | // "js/app.js": /^js/,
11 | // "js/vendor.js": /^(?!js)/
12 | // }
13 | //
14 | // To change the order of concatenation of files, explicitly mention here
15 | // order: {
16 | // before: [
17 | // "vendor/js/jquery-2.1.1.js",
18 | // "vendor/js/bootstrap.min.js"
19 | // ]
20 | // }
21 | },
22 | stylesheets: {
23 | joinTo: "css/app.css"
24 | },
25 | templates: {
26 | joinTo: "js/app.js"
27 | }
28 | },
29 |
30 | conventions: {
31 | // This option sets where we should place non-css and non-js assets in.
32 | // By default, we set this to "/assets/static". Files in this directory
33 | // will be copied to `paths.public`, which is "priv/static" by default.
34 | assets: /^(static)/
35 | },
36 |
37 | // Phoenix paths configuration
38 | paths: {
39 | // Dependencies and current project directories to watch
40 | watched: ["static", "css", "js", "vendor"],
41 | // Where to compile files to
42 | public: "../priv/static"
43 | },
44 |
45 | // Configure your plugins
46 | plugins: {
47 | babel: {
48 | presets: ["env", "react"],
49 | // Do not use ES6 compiler in vendor code
50 | ignore: [/vendor/]
51 | },
52 | sass: {
53 | mode: "native"
54 | }
55 | },
56 |
57 | modules: {
58 | autoRequire: {
59 | "js/app.js": ["js/app"]
60 | }
61 | },
62 |
63 | npm: {
64 | enabled: true
65 | }
66 | };
67 |
--------------------------------------------------------------------------------
/lib/ztd_web/channels/todo_events.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Channels.TodoEvents do
2 | use Phoenix.Channel
3 |
4 | alias ZTD.Todo
5 | alias ZTD.Todo.Event
6 | alias ZTD.Web.Endpoint
7 |
8 |
9 | @channel "todo_events"
10 | @relay "event"
11 |
12 |
13 |
14 |
15 |
16 | # Public API
17 | # ----------
18 |
19 |
20 | @doc """
21 | Broadcasts a Todo Event to all connected clients on the
22 | channel
23 |
24 | NOTE:
25 | This method is being called from the main Todo modules,
26 | which may cause weird issues in situations where the
27 | Endpoint process hasn't been started but this method is
28 | called. Consider wrapping this in another module which
29 | verifies the Endpoint process has already been started
30 | as part of the supervision tree.
31 | """
32 | def broadcast!(%Event{} = event) do
33 | Endpoint.broadcast!(@channel, @relay, event)
34 | end
35 |
36 |
37 |
38 |
39 |
40 | # Callbacks
41 | # ---------
42 |
43 |
44 | # Join Channel
45 |
46 | def join(@channel, _payload, socket) do
47 | {:ok, socket}
48 | end
49 |
50 |
51 |
52 | # Handle Events
53 |
54 | def handle_in("insert", payload, socket) do
55 | item = parse(payload)
56 | Todo.insert(item)
57 | {:noreply, socket}
58 | end
59 |
60 |
61 | def handle_in("update", payload, socket) do
62 | item = %{id: id} = parse(payload)
63 | Todo.update(id, item)
64 | {:noreply, socket}
65 | end
66 |
67 |
68 | def handle_in("delete", payload, socket) do
69 | item = %{id: id} = parse(payload)
70 | Todo.delete(id)
71 | {:noreply, socket}
72 | end
73 |
74 |
75 |
76 |
77 | # Private Helpers
78 | # ---------------
79 |
80 | defp parse(payload) do
81 | payload
82 | |> BetterParams.symbolize_merge(drop_string_keys: true)
83 | |> Map.get(:data)
84 | end
85 |
86 |
87 | end
88 |
--------------------------------------------------------------------------------
/lib/ztd_web/endpoint.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web.Endpoint do
2 | use Phoenix.Endpoint, otp_app: :ztd
3 |
4 | socket "/socket", ZTD.Web.Sockets.Main
5 |
6 | # Serve at "/" the static files from "priv/static" directory.
7 | #
8 | # You should set gzip to true if you are running phoenix.digest
9 | # when deploying your static files in production.
10 | plug Plug.Static,
11 | at: "/", from: :ztd, gzip: false,
12 | only: ~w(css fonts images js favicon.ico robots.txt)
13 |
14 | # Code reloading can be explicitly enabled under the
15 | # :code_reloader configuration of your endpoint.
16 | if code_reloading? do
17 | socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
18 | plug Phoenix.LiveReloader
19 | plug Phoenix.CodeReloader
20 | end
21 |
22 | plug Plug.Logger
23 |
24 | plug Plug.Parsers,
25 | parsers: [:urlencoded, :multipart, :json],
26 | pass: ["*/*"],
27 | json_decoder: Poison
28 |
29 | plug Plug.MethodOverride
30 | plug Plug.Head
31 |
32 | # The session will be stored in the cookie and signed,
33 | # this means its contents can be read but not tampered with.
34 | # Set :encryption_salt if you would also like to encrypt it.
35 | plug Plug.Session,
36 | store: :cookie,
37 | key: "_ztd_key",
38 | signing_salt: "ekKX31ic"
39 |
40 | plug ZTD.Web.Router
41 |
42 | @doc """
43 | Callback invoked for dynamically configuring the endpoint.
44 |
45 | It receives the endpoint configuration and checks if
46 | configuration should be loaded from the system environment.
47 | """
48 | def init(_key, config) do
49 | if config[:load_from_system_env] do
50 | port = System.get_env("PORT") || raise "expected the PORT environment variable to be set"
51 | {:ok, Keyword.put(config, :http, [:inet6, port: port])}
52 | else
53 | {:ok, config}
54 | end
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/lib/ztd/todo/engine/broadcaster.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Engine.Broadcaster do
2 | use GenServer
3 |
4 | alias ZTD.Todo.Event
5 | alias ZTD.Todo.Config
6 | alias ZTD.Web.Channels
7 |
8 | @exchange Config.get(:amqp)[:broadcast_exchange]
9 | @routing Config.get(:amqp)[:broadcast_routing]
10 |
11 |
12 | @moduledoc """
13 | Keeps a RabbitMQ connection open to a fanout exchange
14 | where each worker is connected to. When messages are
15 | broadcasted, they're sent to all workers, and also to
16 | all the Phoenix channels (locally, on each instance).
17 | """
18 |
19 |
20 |
21 |
22 | ## Public API
23 | ## ----------
24 |
25 |
26 | @doc "Open the connection"
27 | def start_link do
28 | GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
29 | end
30 |
31 |
32 | @doc "Broadcast event on the fanout exchange"
33 | def broadcast!(%Event{} = event) do
34 | GenServer.cast(__MODULE__, {:broadcast, event})
35 | end
36 |
37 |
38 |
39 |
40 |
41 | ## Callbacks
42 | ## ---------
43 |
44 |
45 | # Initialize State
46 | @doc false
47 | def init(:ok) do
48 | # Create Connection & Channel
49 | {:ok, connection} = AMQP.Connection.open
50 | {:ok, channel} = AMQP.Channel.open(connection)
51 |
52 | # Declare Fanout Exchange
53 | AMQP.Exchange.declare(channel, @exchange, :fanout)
54 |
55 | {:ok, channel}
56 | end
57 |
58 |
59 |
60 | # Handle cast for :broadcast
61 | @doc false
62 | def handle_cast({:broadcast, event}, channel) do
63 | message = Event.encode!(event)
64 |
65 | # Broadcast on both Websocket and RabbitMQ
66 | Channels.TodoEvents.broadcast!(event)
67 | AMQP.Basic.publish(channel, @exchange, @routing, message)
68 |
69 | {:noreply, channel}
70 | end
71 |
72 |
73 |
74 | # Discard all info messages
75 | @doc false
76 | def handle_info(_message, state) do
77 | {:noreply, state}
78 | end
79 |
80 |
81 | end
82 |
--------------------------------------------------------------------------------
/lib/ztd/todo/worker/dispatcher.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Worker.Dispatcher do
2 | use GenServer
3 |
4 | alias ZTD.Todo.Event
5 | alias ZTD.Todo.Config
6 |
7 | @queue Config.get(:amqp)[:request_queue]
8 | @exchange Config.get(:amqp)[:request_exchange]
9 |
10 |
11 | @moduledoc """
12 | Keeps a RabbitMQ connection open to the engine. Sends
13 | todo events to the engine where it is responsible for
14 | persisting it and broadcasting the event to all
15 | connected workers (including self). This acts as an
16 | acknowledgement and the state is updated.
17 | """
18 |
19 |
20 |
21 |
22 |
23 | ## Public API
24 | ## ----------
25 |
26 |
27 | @doc "Open the connection"
28 | def start_link do
29 | GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
30 | end
31 |
32 |
33 | @doc "Send event to Engine"
34 | def send!(%Event{} = event) do
35 | GenServer.cast(__MODULE__, {:send, event})
36 | end
37 |
38 |
39 |
40 |
41 |
42 | ## Callbacks
43 | ## ---------
44 |
45 |
46 | # Initialize State
47 | @doc false
48 | def init(:ok) do
49 | # Create Connection & Channel
50 | {:ok, connection} = AMQP.Connection.open
51 | {:ok, channel} = AMQP.Channel.open(connection)
52 |
53 | # Declare Exchange & Queue
54 | AMQP.Exchange.declare(channel, @exchange, :direct)
55 | AMQP.Queue.declare(channel, @queue, durable: false)
56 | AMQP.Queue.bind(channel, @queue, @exchange, routing_key: @queue)
57 |
58 | {:ok, channel}
59 | end
60 |
61 |
62 |
63 | # Handle cast for :send!
64 | @doc false
65 | def handle_cast({:send, event}, channel) do
66 | message = Event.encode!(event)
67 | AMQP.Basic.publish(channel, @exchange, @queue, message, type: "event")
68 |
69 | {:noreply, channel}
70 | end
71 |
72 |
73 |
74 | # Discard all info messages
75 | @doc false
76 | def handle_info(_message, state) do
77 | {:noreply, state}
78 | end
79 |
80 |
81 | end
82 |
--------------------------------------------------------------------------------
/assets/js/components/todo/todo-item.js:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import PropTypes from 'prop-types'
3 | import _ from 'lodash'
4 |
5 |
6 | class TodoItem extends React.Component {
7 | constructor(props) {
8 | super(props);
9 |
10 | this.handleDone = this.handleDone.bind(this);
11 | this.handleEdit = this.handleEdit.bind(this);
12 | this.handleDelete = this.handleDelete.bind(this);
13 | }
14 |
15 |
16 | handleDone() {
17 | const {item} = this.props;
18 | const updated = _.merge(item, {done: !item.done});
19 | this.props.broadcast("update", item);
20 | }
21 |
22 | handleEdit(e) {
23 | const {item} = this.props;
24 | const updated = _.merge(item, {title: e.target.value});
25 | this.props.broadcast("update", item);
26 | }
27 |
28 | handleDelete() {
29 | const {item} = this.props;
30 | this.props.broadcast("delete", item);
31 | }
32 |
33 |
34 |
35 | render() {
36 | const {item} = this.props;
37 | const doneClass = item.done ? 'is-done' : '';
38 |
39 | return (
40 |
58 | );
59 | }
60 | }
61 |
62 |
63 |
64 | // Prop Specification
65 | TodoItem.propTypes = {
66 | broadcast: PropTypes.func.isRequired,
67 | item: PropTypes.shape({
68 | id: PropTypes.string.isRequired,
69 | title: PropTypes.string.isRequired,
70 | done: PropTypes.bool.isRequired,
71 | }).isRequired,
72 | };
73 |
74 |
75 |
76 | // Export
77 | export default TodoItem;
78 |
79 |
--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 |
3 | # For development, we disable any cache and enable
4 | # debugging and code reloading.
5 | #
6 | # The watchers configuration can be used to run external
7 | # watchers to your application. For example, we use it
8 | # with brunch.io to recompile .js and .css sources.
9 | config :ztd, ZTD.Web.Endpoint,
10 | http: [port: System.get_env("PORT") || 4000],
11 | debug_errors: true,
12 | code_reloader: true,
13 | check_origin: false,
14 | watchers: [node: ["node_modules/brunch/bin/brunch", "watch", "--stdin",
15 | cd: Path.expand("../assets", __DIR__)]]
16 |
17 | # ## SSL Support
18 | #
19 | # In order to use HTTPS in development, a self-signed
20 | # certificate can be generated by running the following
21 | # command from your terminal:
22 | #
23 | # openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout priv/server.key -out priv/server.pem
24 | #
25 | # The `http:` config above can be replaced with:
26 | #
27 | # https: [port: 4000, keyfile: "priv/server.key", certfile: "priv/server.pem"],
28 | #
29 | # If desired, both `http:` and `https:` keys can be
30 | # configured to run both http and https servers on
31 | # different ports.
32 |
33 | # Watch static and templates for browser reloading.
34 | config :ztd, ZTD.Web.Endpoint,
35 | live_reload: [
36 | patterns: [
37 | ~r{priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$},
38 | ~r{priv/gettext/.*(po)$},
39 | ~r{lib/ztd_web/views/.*(ex)$},
40 | ~r{lib/ztd_web/templates/.*(eex)$}
41 | ]
42 | ]
43 |
44 | # Do not include metadata nor timestamps in development logs
45 | config :logger, :console, format: "[$level] $message\n"
46 |
47 | # Set a higher stacktrace during development. Avoid configuring such
48 | # in production as building large stacktraces may be expensive.
49 | config :phoenix, :stacktrace_depth, 20
50 |
51 | # Configure your database
52 | config :ztd, ZTD.Repo,
53 | adapter: Ecto.Adapters.Postgres,
54 | username: "postgres",
55 | password: "postgres",
56 | database: "ztd_dev",
57 | hostname: "localhost",
58 | pool_size: 10
59 |
--------------------------------------------------------------------------------
/lib/ztd_web.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Web do
2 | @moduledoc """
3 | The entrypoint for defining your web interface, such
4 | as controllers, views, channels and so on.
5 |
6 | This can be used in your application as:
7 |
8 | use ZTD.Web, :controller
9 | use ZTD.Web, :view
10 |
11 | The definitions below will be executed for every view,
12 | controller, etc, so keep them short and clean, focused
13 | on imports, uses and aliases.
14 |
15 | Do NOT define functions inside the quoted expressions
16 | below. Instead, define any helper function in modules
17 | and import those modules here.
18 | """
19 |
20 |
21 | def controller do
22 | quote do
23 | use Phoenix.Controller, namespace: ZTD.Web
24 | alias ZTD.Web.Router.Helpers, as: Router
25 |
26 | import Plug.Conn
27 | import ZTD.Web.Gettext
28 |
29 | plug :put_view, ZTD.Web.inflect_view(__MODULE__)
30 | plug :put_layout, {ZTD.Web.Views.Layout, :app}
31 | end
32 | end
33 |
34 |
35 | def view do
36 | quote do
37 | use Phoenix.HTML
38 | use Phoenix.View,
39 | root: "lib/ztd_web/templates",
40 | namespace: ZTD.Web.Views
41 |
42 | alias ZTD.Web.Router.Helpers, as: Router
43 | alias ReactPhoenix.ClientSide, as: React
44 |
45 | import Phoenix.Controller, only: [get_flash: 2, view_module: 1]
46 | import ZTD.Web.ErrorHelpers
47 | import ZTD.Web.Gettext
48 | end
49 | end
50 |
51 |
52 | def router do
53 | quote do
54 | use Phoenix.Router
55 |
56 | import Plug.Conn
57 | import Phoenix.Controller
58 | end
59 | end
60 |
61 |
62 | def channel do
63 | quote do
64 | use Phoenix.Channel
65 | import ZTD.Web.Gettext
66 | end
67 | end
68 |
69 |
70 |
71 | @doc """
72 | When used, dispatch to the appropriate controller/view/etc.
73 | """
74 | defmacro __using__(which) when is_atom(which) do
75 | apply(__MODULE__, which, [])
76 | end
77 |
78 |
79 |
80 | # Figure out what View / Template to use from Controller Module
81 | def inflect_view(controller) do
82 | controller
83 | |> to_string
84 | |> String.replace("Controllers", "Views")
85 | |> String.to_atom
86 | end
87 |
88 | end
89 |
--------------------------------------------------------------------------------
/lib/ztd/todo/worker/rpc.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Worker.RPC do
2 | alias ZTD.Todo.Config
3 |
4 |
5 | @moduledoc """
6 | RPC Client interface to the engine. Sends rpc
7 | requests via RabbitMQ to the engine and waits
8 | for their response on an exclusive queue.
9 |
10 | NOTE:
11 | Highly inefficient over the network because it
12 | blocks until it receives response. Consider
13 | implementing a truly distributed version (but
14 | it would require each worker to have own
15 | state).
16 |
17 | Maybe also keep the connection/channel open.
18 | """
19 |
20 |
21 | @request_queue Config.get(:amqp)[:request_queue]
22 | @request_exchange Config.get(:amqp)[:request_exchange]
23 | @timeout 2_000
24 |
25 |
26 |
27 |
28 |
29 | ## Public API
30 | ## ----------
31 |
32 | def all do
33 | rpc_request!("all")
34 | end
35 |
36 |
37 |
38 |
39 |
40 | ## Private Helpers
41 | ## ---------------
42 |
43 |
44 | # Generate a random correlation id
45 | defp generate_id do
46 | :erlang.unique_integer
47 | |> :erlang.integer_to_binary
48 | |> Base.encode64
49 | end
50 |
51 |
52 | # Open a Connection
53 | defp open_connection do
54 | {:ok, connection} = AMQP.Connection.open
55 | {:ok, channel} = AMQP.Channel.open(connection)
56 | {:ok, %{queue: queue}} = AMQP.Queue.declare(channel, "", exclusive: true)
57 |
58 | {connection, channel, queue}
59 | end
60 |
61 |
62 | # Perform an RPC Request
63 | defp rpc_request!(command) do
64 | id = generate_id()
65 | conn = {_, channel, queue} = open_connection()
66 |
67 | AMQP.Basic.consume(channel, queue, nil, no_ack: true)
68 | AMQP.Basic.publish(
69 | channel,
70 | @request_exchange,
71 | @request_queue,
72 | command,
73 | type: "rpc",
74 | reply_to: queue,
75 | correlation_id: id
76 | )
77 |
78 | wait_for_response(conn, id)
79 | end
80 |
81 |
82 | # Block until receive RPC response with matching id
83 | defp wait_for_response(conn, id) do
84 | receive do
85 | {:basic_deliver, payload, %{correlation_id: ^id}} ->
86 | Poison.decode!(payload)
87 | after
88 | @timeout -> raise "RPC Call Timed out"
89 | end
90 | end
91 |
92 |
93 | end
94 |
95 |
--------------------------------------------------------------------------------
/test/ztd_web/channels/todo_events_test.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Web.Channels.TodoEvents do
2 | use ZTD.Tests.Support.ChannelCase
3 |
4 | alias ZTD.Todo.Engine.Schema, as: Item
5 | alias ZTD.Web.Channels.TodoEvents
6 |
7 |
8 | @channel TodoEvents
9 | @room "todo_events"
10 | @relay "event"
11 |
12 |
13 |
14 | setup do
15 | {:ok, _, socket} =
16 | "user_id"
17 | |> socket(%{})
18 | |> subscribe_and_join(@channel, @room)
19 |
20 | [socket: socket]
21 | end
22 |
23 |
24 |
25 | # NOTE:
26 | # Have separate tests for broadcasts
27 |
28 |
29 | describe "#handle_in" do
30 | @event "insert"
31 | test "inserts new items on insert event", %{socket: socket} do
32 | assert length(Item.all) == 0
33 |
34 | new = %{title: "get milk"}
35 | push(socket, @event, %{data: new})
36 | assert_broadcast!(@event, %{data: %{title: new.title}})
37 | Support.wait
38 |
39 | assert [item] = Item.all
40 | assert item.title == new.title
41 | end
42 |
43 |
44 | @event "update"
45 | test "updates existing items", %{socket: socket} do
46 | old = Item.insert!(title: "done item", done: true)
47 | new = %{id: old.id, title: "pending", done: false}
48 |
49 | push(socket, @event, %{data: new})
50 | assert_broadcast!(@event, %{data: %{title: new.title}})
51 | Support.wait
52 |
53 | assert item = Item.get(old.id)
54 | assert item.title == new.title
55 | assert item.done == new.done
56 | end
57 |
58 |
59 | @event "delete"
60 | test "deletes existing items", %{socket: socket} do
61 | item_1 = Item.insert!(title: "done item", done: true)
62 | item_2 = Item.insert!(title: "pending item", done: false)
63 |
64 | push(socket, @event, %{data: %{id: item_1.id}})
65 | assert_broadcast!(@event, %{data: %{id: item_1.id}})
66 | Support.wait
67 |
68 | refute Item.get(item_1.id)
69 | assert Item.get(item_2.id)
70 | end
71 | end
72 |
73 |
74 |
75 |
76 | # Private Helpers
77 | # ---------------
78 |
79 |
80 | # NOTE:
81 | # There is something weird happening here. Fix it.
82 | defp assert_broadcast!(event, payload) do
83 | payload = Map.put(payload, :type, String.to_atom(event))
84 | assert_broadcast(@relay, payload)
85 | end
86 |
87 | end
88 |
--------------------------------------------------------------------------------
/config/prod.exs:
--------------------------------------------------------------------------------
1 | use Mix.Config
2 |
3 | # For production, we often load configuration from external
4 | # sources, such as your system environment. For this reason,
5 | # you won't find the :http configuration below, but set inside
6 | # ZTD.Web.Endpoint.init/2 when load_from_system_env is
7 | # true. Any dynamic configuration should be done there.
8 | #
9 | # Don't forget to configure the url host to something meaningful,
10 | # Phoenix uses this information when generating URLs.
11 | #
12 | # Finally, we also include the path to a cache manifest
13 | # containing the digested version of static files. This
14 | # manifest is generated by the mix phx.digest task
15 | # which you typically run after static files are built.
16 | config :ztd, ZTD.Web.Endpoint,
17 | load_from_system_env: true,
18 | url: [host: "example.com", port: 80],
19 | cache_static_manifest: "priv/static/cache_manifest.json"
20 |
21 | # Do not print debug messages in production
22 | config :logger, level: :info
23 |
24 | # ## SSL Support
25 | #
26 | # To get SSL working, you will need to add the `https` key
27 | # to the previous section and set your `:url` port to 443:
28 | #
29 | # config :ztd, ZTD.Web.Endpoint,
30 | # ...
31 | # url: [host: "example.com", port: 443],
32 | # https: [:inet6,
33 | # port: 443,
34 | # keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
35 | # certfile: System.get_env("SOME_APP_SSL_CERT_PATH")]
36 | #
37 | # Where those two env variables return an absolute path to
38 | # the key and cert in disk or a relative path inside priv,
39 | # for example "priv/ssl/server.key".
40 | #
41 | # We also recommend setting `force_ssl`, ensuring no data is
42 | # ever sent via http, always redirecting to https:
43 | #
44 | # config :ztd, ZTD.Web.Endpoint,
45 | # force_ssl: [hsts: true]
46 | #
47 | # Check `Plug.SSL` for all available options in `force_ssl`.
48 |
49 | # ## Using releases
50 | #
51 | # If you are doing OTP releases, you need to instruct Phoenix
52 | # to start the server for all endpoints:
53 | #
54 | # config :phoenix, :serve_endpoints, true
55 | #
56 | # Alternatively, you can configure exactly which server to
57 | # start per endpoint:
58 | #
59 | # config :ztd, ZTD.Web.Endpoint, server: true
60 | #
61 |
62 | # Finally import the config/prod.secret.exs
63 | # which should be versioned separately.
64 | import_config "prod.secret.exs"
65 |
--------------------------------------------------------------------------------
/assets/js/socket.js:
--------------------------------------------------------------------------------
1 | // NOTE: The contents of this file will only be executed if
2 | // you uncomment its entry in "assets/js/app.js".
3 |
4 | // To use Phoenix channels, the first step is to import Socket
5 | // and connect at the socket path in "lib/web/endpoint.ex":
6 | import {Socket} from "phoenix"
7 |
8 | let socket = new Socket("/socket", {params: {token: window.userToken}})
9 |
10 | // When you connect, you'll often need to authenticate the client.
11 | // For example, imagine you have an authentication plug, `MyAuth`,
12 | // which authenticates the session and assigns a `:current_user`.
13 | // If the current user exists you can assign the user's token in
14 | // the connection for use in the layout.
15 | //
16 | // In your "lib/web/router.ex":
17 | //
18 | // pipeline :browser do
19 | // ...
20 | // plug MyAuth
21 | // plug :put_user_token
22 | // end
23 | //
24 | // defp put_user_token(conn, _) do
25 | // if current_user = conn.assigns[:current_user] do
26 | // token = Phoenix.Token.sign(conn, "user socket", current_user.id)
27 | // assign(conn, :user_token, token)
28 | // else
29 | // conn
30 | // end
31 | // end
32 | //
33 | // Now you need to pass this token to JavaScript. You can do so
34 | // inside a script tag in "lib/web/templates/layout/app.html.eex":
35 | //
36 | //
37 | //
38 | // You will need to verify the user token in the "connect/2" function
39 | // in "lib/web/channels/user_socket.ex":
40 | //
41 | // def connect(%{"token" => token}, socket) do
42 | // # max_age: 1209600 is equivalent to two weeks in seconds
43 | // case Phoenix.Token.verify(socket, "user socket", token, max_age: 1209600) do
44 | // {:ok, user_id} ->
45 | // {:ok, assign(socket, :user, user_id)}
46 | // {:error, reason} ->
47 | // :error
48 | // end
49 | // end
50 | //
51 | // Finally, pass the token on connect as below. Or remove it
52 | // from connect if you don't care about authentication.
53 |
54 | socket.connect()
55 |
56 | // Now that you are connected, you can join channels with a topic:
57 | // let channel = socket.channel("topic:subtopic", {})
58 | // channel.join()
59 | // .receive("ok", resp => { console.log("Joined successfully", resp) })
60 | // .receive("error", resp => { console.log("Unable to join", resp) })
61 |
62 | export default socket
63 |
--------------------------------------------------------------------------------
/test/ztd/todo/engine_test.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Todo.Engine do
2 | use ZTD.Tests.Support.Case
3 |
4 | alias ZTD.Todo.Engine
5 |
6 |
7 |
8 | describe "all/0" do
9 | test "returns empty list when no todo items exist" do
10 | assert Engine.all == []
11 | end
12 |
13 |
14 | test "returns items in ascending order of creation date" do
15 | Engine.Schema.insert!(title: "Done 1", done: true)
16 | Engine.Schema.insert!(title: "Pending 1", done: false)
17 | Engine.Schema.insert!(title: "Pending 2", done: false)
18 | Engine.Schema.insert!(title: "Done 2", done: true)
19 |
20 | items = Engine.all |> Enum.map(&(&1.title))
21 | assert items == ["Done 1", "Pending 1", "Pending 2", "Done 2"]
22 | end
23 | end
24 |
25 |
26 |
27 | describe "insert/1" do
28 | test "returns :ok for valid params" do
29 | assert {:ok, _} = Engine.insert(%{title: "Buy Milk"})
30 | assert 1 = length(Engine.Schema.all)
31 |
32 | assert {:ok, _} = Engine.insert(%{title: "Buy Eggs", done: true})
33 | assert 2 = length(Engine.Schema.all)
34 | end
35 |
36 |
37 | test "return :error for invalid params" do
38 | assert {:error, changeset} = Engine.insert(%{title: nil})
39 | assert error_message(changeset, :title) =~ ~r/can't be blank/
40 | end
41 | end
42 |
43 |
44 |
45 | describe "update/2" do
46 | setup do
47 | [item: Engine.Schema.insert!(title: "Some Engine.Schema")]
48 | end
49 |
50 |
51 | test "can update the title of an item", %{item: item} do
52 | assert {:ok, item} = Engine.update(item.id, %{title: "New Name"})
53 | assert item.title == "New Name"
54 | end
55 |
56 |
57 | test "can mark items done", %{item: item} do
58 | assert {:ok, item} = Engine.update(item.id, %{done: true})
59 | assert item.done == true
60 | end
61 | end
62 |
63 |
64 |
65 | describe "delete/1" do
66 | setup do
67 | [item: Engine.Schema.insert!(title: "Some Engine.Schema")]
68 | end
69 |
70 |
71 | test "deletes an item if it exists", %{item: item} do
72 | assert {:ok, _} = Engine.delete(item.id)
73 | assert 0 = length(Engine.Schema.all)
74 | end
75 |
76 |
77 | test "does nothing if the item does not exist" do
78 | unknown_id = Ecto.UUID.generate
79 | assert {:ok, _} = Engine.delete(unknown_id)
80 | assert 1 = length(Engine.Schema.all)
81 | end
82 | end
83 |
84 | end
85 |
--------------------------------------------------------------------------------
/lib/ztd/todo/worker/listener.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Worker.Listener do
2 | use GenServer
3 | require Logger
4 |
5 | alias ZTD.Todo.Event
6 | alias ZTD.Todo.Config
7 | alias ZTD.Web.Channels
8 |
9 | @exchange Config.get(:amqp)[:broadcast_exchange]
10 | @routing Config.get(:amqp)[:broadcast_routing]
11 | @queue ""
12 |
13 |
14 | @moduledoc """
15 | Creates a temporary queue bound to the fanout exchange,
16 | listening for events broadcasted from the engine. When
17 | messages are received they are then broadcasted to the
18 | clients connected on the Phoenix Channel as well.
19 | """
20 |
21 |
22 |
23 |
24 | ## Public API
25 | ## ----------
26 |
27 |
28 | @doc "Open the connection"
29 | def start_link do
30 | GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
31 | end
32 |
33 |
34 |
35 |
36 |
37 | ## Callbacks
38 | ## ---------
39 |
40 |
41 | # Initialize State
42 | @doc false
43 | def init(:ok) do
44 | # Create Connection & Channel
45 | {:ok, connection} = AMQP.Connection.open
46 | {:ok, channel} = AMQP.Channel.open(connection)
47 |
48 | # Declare Exchange & Queue
49 | AMQP.Exchange.declare(channel, @exchange, :fanout)
50 | {:ok, %{queue: queue}} = AMQP.Queue.declare(channel, @queue, exclusive: true)
51 | AMQP.Queue.bind(channel, @queue, @exchange, routing_key: @routing)
52 |
53 | # Start Consuming
54 | AMQP.Basic.consume(channel, queue, nil, no_ack: true)
55 |
56 | {:ok, channel}
57 | end
58 |
59 |
60 |
61 | # Receive Messages
62 | @doc false
63 | def handle_info({:basic_deliver, payload, meta}, channel) do
64 | Logger.debug("Received Message: #{inspect payload}")
65 |
66 | spawn fn ->
67 | consume(payload, meta)
68 | end
69 |
70 | {:noreply, channel}
71 | end
72 |
73 |
74 |
75 | # Discard all other messages
76 | @doc false
77 | def handle_info(message, state) do
78 | Logger.debug("Received info: #{inspect message}")
79 | {:noreply, state}
80 | end
81 |
82 |
83 |
84 |
85 |
86 |
87 | ## Private Helpers
88 | ## ---------------
89 |
90 |
91 | # Parse the event and perform the actions
92 | defp consume(payload, _meta) do
93 | payload
94 | |> Event.decode!
95 | |> Channels.TodoEvents.broadcast!
96 | rescue
97 | Event.InvalidError ->
98 | raise "Received invalid event data #{inspect(payload)}"
99 | end
100 |
101 | end
102 |
103 |
--------------------------------------------------------------------------------
/test/ztd/todo/config_test.exs:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Tests.Todo.Config do
2 | use ZTD.Tests.Support.Case
3 | alias ZTD.Todo.Config
4 |
5 |
6 | setup do
7 | configs = Application.get_env(:ztd, :todo)
8 |
9 | on_exit fn ->
10 | # Revert to default mode
11 | set_mode(configs[:default])
12 | end
13 |
14 | [configs: configs]
15 | end
16 |
17 |
18 |
19 | describe "get/0" do
20 | test "returns application config specified under :todo key", %{configs: configs} do
21 | assert Config.get == configs
22 | end
23 | end
24 |
25 |
26 |
27 | describe "get/2" do
28 | @key :env_var
29 | test "returns the nested config for given key", %{configs: configs} do
30 | assert Config.get(@key) == configs[@key]
31 | end
32 |
33 |
34 | @key :unknown_key
35 | test "returns the default value when nothing specified" do
36 | refute Config.get(@key)
37 | assert Config.get(@key, :default) == :default
38 | end
39 | end
40 |
41 |
42 |
43 | describe "mode/0" do
44 | test "returns default mode when not specified", %{configs: configs} do
45 | set_mode(nil)
46 | assert Config.mode == configs[:default]
47 | end
48 |
49 |
50 | test "returns the mode when specified" do
51 | set_mode(:engine)
52 | assert Config.mode == :engine
53 |
54 | set_mode(:worker)
55 | assert Config.mode == :worker
56 | end
57 |
58 |
59 | test "raises error for invalid modes" do
60 | assert_raise(RuntimeError, ~r/unknown application mode/i, fn ->
61 | set_mode(:invalid_mode)
62 | Config.mode
63 | end)
64 | end
65 | end
66 |
67 |
68 |
69 | describe "adapter/0" do
70 | test "returns the correct adapter when mode is specified", %{configs: configs} do
71 | set_mode(:engine)
72 | assert Config.adapter == configs[:adapters][:engine]
73 |
74 | set_mode(:worker)
75 | assert Config.adapter == configs[:adapters][:worker]
76 | end
77 |
78 |
79 | test "raises error for invalid modes" do
80 | assert_raise(RuntimeError, fn ->
81 | set_mode(:invalid_mode)
82 | Config.adapter
83 | end)
84 | end
85 | end
86 |
87 |
88 |
89 |
90 | # Private Helpers
91 | # ---------------
92 |
93 | defp set_mode(mode) do
94 | mode = String.upcase("#{mode}")
95 |
96 | :env_var
97 | |> Config.get
98 | |> System.put_env(mode)
99 | end
100 |
101 |
102 | end
103 |
--------------------------------------------------------------------------------
/priv/gettext/en/LC_MESSAGES/errors.po:
--------------------------------------------------------------------------------
1 | ## `msgid`s in this file come from POT (.pot) files.
2 | ##
3 | ## Do not add, change, or remove `msgid`s manually here as
4 | ## they're tied to the ones in the corresponding POT file
5 | ## (with the same domain).
6 | ##
7 | ## Use `mix gettext.extract --merge` or `mix gettext.merge`
8 | ## to merge POT files into PO files.
9 | msgid ""
10 | msgstr ""
11 | "Language: en\n"
12 |
13 | ## From Ecto.Changeset.cast/4
14 | msgid "can't be blank"
15 | msgstr ""
16 |
17 | ## From Ecto.Changeset.unique_constraint/3
18 | msgid "has already been taken"
19 | msgstr ""
20 |
21 | ## From Ecto.Changeset.put_change/3
22 | msgid "is invalid"
23 | msgstr ""
24 |
25 | ## From Ecto.Changeset.validate_acceptance/3
26 | msgid "must be accepted"
27 | msgstr ""
28 |
29 | ## From Ecto.Changeset.validate_format/3
30 | msgid "has invalid format"
31 | msgstr ""
32 |
33 | ## From Ecto.Changeset.validate_subset/3
34 | msgid "has an invalid entry"
35 | msgstr ""
36 |
37 | ## From Ecto.Changeset.validate_exclusion/3
38 | msgid "is reserved"
39 | msgstr ""
40 |
41 | ## From Ecto.Changeset.validate_confirmation/3
42 | msgid "does not match confirmation"
43 | msgstr ""
44 |
45 | ## From Ecto.Changeset.no_assoc_constraint/3
46 | msgid "is still associated with this entry"
47 | msgstr ""
48 |
49 | msgid "are still associated with this entry"
50 | msgstr ""
51 |
52 | ## From Ecto.Changeset.validate_length/3
53 | msgid "should be %{count} character(s)"
54 | msgid_plural "should be %{count} character(s)"
55 | msgstr[0] ""
56 | msgstr[1] ""
57 |
58 | msgid "should have %{count} item(s)"
59 | msgid_plural "should have %{count} item(s)"
60 | msgstr[0] ""
61 | msgstr[1] ""
62 |
63 | msgid "should be at least %{count} character(s)"
64 | msgid_plural "should be at least %{count} character(s)"
65 | msgstr[0] ""
66 | msgstr[1] ""
67 |
68 | msgid "should have at least %{count} item(s)"
69 | msgid_plural "should have at least %{count} item(s)"
70 | msgstr[0] ""
71 | msgstr[1] ""
72 |
73 | msgid "should be at most %{count} character(s)"
74 | msgid_plural "should be at most %{count} character(s)"
75 | msgstr[0] ""
76 | msgstr[1] ""
77 |
78 | msgid "should have at most %{count} item(s)"
79 | msgid_plural "should have at most %{count} item(s)"
80 | msgstr[0] ""
81 | msgstr[1] ""
82 |
83 | ## From Ecto.Changeset.validate_number/3
84 | msgid "must be less than %{number}"
85 | msgstr ""
86 |
87 | msgid "must be greater than %{number}"
88 | msgstr ""
89 |
90 | msgid "must be less than or equal to %{number}"
91 | msgstr ""
92 |
93 | msgid "must be greater than or equal to %{number}"
94 | msgstr ""
95 |
96 | msgid "must be equal to %{number}"
97 | msgstr ""
98 |
--------------------------------------------------------------------------------
/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
1 | ## This file is a PO Template file.
2 | ##
3 | ## `msgid`s here are often extracted from source code.
4 | ## Add new translations manually only if they're dynamic
5 | ## translations that can't be statically extracted.
6 | ##
7 | ## Run `mix gettext.extract` to bring this file up to
8 | ## date. Leave `msgstr`s empty as changing them here as no
9 | ## effect: edit them in PO (`.po`) files instead.
10 |
11 | ## From Ecto.Changeset.cast/4
12 | msgid "can't be blank"
13 | msgstr ""
14 |
15 | ## From Ecto.Changeset.unique_constraint/3
16 | msgid "has already been taken"
17 | msgstr ""
18 |
19 | ## From Ecto.Changeset.put_change/3
20 | msgid "is invalid"
21 | msgstr ""
22 |
23 | ## From Ecto.Changeset.validate_acceptance/3
24 | msgid "must be accepted"
25 | msgstr ""
26 |
27 | ## From Ecto.Changeset.validate_format/3
28 | msgid "has invalid format"
29 | msgstr ""
30 |
31 | ## From Ecto.Changeset.validate_subset/3
32 | msgid "has an invalid entry"
33 | msgstr ""
34 |
35 | ## From Ecto.Changeset.validate_exclusion/3
36 | msgid "is reserved"
37 | msgstr ""
38 |
39 | ## From Ecto.Changeset.validate_confirmation/3
40 | msgid "does not match confirmation"
41 | msgstr ""
42 |
43 | ## From Ecto.Changeset.no_assoc_constraint/3
44 | msgid "is still associated with this entry"
45 | msgstr ""
46 |
47 | msgid "are still associated with this entry"
48 | msgstr ""
49 |
50 | ## From Ecto.Changeset.validate_length/3
51 | msgid "should be %{count} character(s)"
52 | msgid_plural "should be %{count} character(s)"
53 | msgstr[0] ""
54 | msgstr[1] ""
55 |
56 | msgid "should have %{count} item(s)"
57 | msgid_plural "should have %{count} item(s)"
58 | msgstr[0] ""
59 | msgstr[1] ""
60 |
61 | msgid "should be at least %{count} character(s)"
62 | msgid_plural "should be at least %{count} character(s)"
63 | msgstr[0] ""
64 | msgstr[1] ""
65 |
66 | msgid "should have at least %{count} item(s)"
67 | msgid_plural "should have at least %{count} item(s)"
68 | msgstr[0] ""
69 | msgstr[1] ""
70 |
71 | msgid "should be at most %{count} character(s)"
72 | msgid_plural "should be at most %{count} character(s)"
73 | msgstr[0] ""
74 | msgstr[1] ""
75 |
76 | msgid "should have at most %{count} item(s)"
77 | msgid_plural "should have at most %{count} item(s)"
78 | msgstr[0] ""
79 | msgstr[1] ""
80 |
81 | ## From Ecto.Changeset.validate_number/3
82 | msgid "must be less than %{number}"
83 | msgstr ""
84 |
85 | msgid "must be greater than %{number}"
86 | msgstr ""
87 |
88 | msgid "must be less than or equal to %{number}"
89 | msgstr ""
90 |
91 | msgid "must be greater than or equal to %{number}"
92 | msgstr ""
93 |
94 | msgid "must be equal to %{number}"
95 | msgstr ""
96 |
--------------------------------------------------------------------------------
/lib/ztd/todo/engine/listener.ex:
--------------------------------------------------------------------------------
1 | defmodule ZTD.Todo.Engine.Listener do
2 | use GenServer
3 | require Logger
4 |
5 | alias ZTD.Todo
6 | alias ZTD.Todo.Event
7 | alias ZTD.Todo.Config
8 |
9 |
10 | @moduledoc """
11 | Listens to events directly sent from workers to the
12 | engine. Performs the operations associated with the
13 | events using the main Engine module, which on success,
14 | broadcast them back to all workers. This acts as an
15 | acknowledgement, updating the workers Web UI state.
16 |
17 | NOTE:
18 | This is inefficient. For making this app "truly"
19 | distributed, consider having atleast a volatile state
20 | for each worker (maybe as a process?). This way we
21 | can reflect changes in UI instantly, and eventually
22 | support CQRS for partition tolerance.
23 |
24 | Also create a separate GenServer for handling RPC
25 | requests.
26 | """
27 |
28 |
29 | @queue Config.get(:amqp)[:request_queue]
30 | @exchange Config.get(:amqp)[:request_exchange]
31 | @rpc ""
32 |
33 |
34 |
35 |
36 | ## Public API
37 | ## ----------
38 |
39 |
40 | @doc "Open the connection"
41 | def start_link do
42 | GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
43 | end
44 |
45 |
46 |
47 |
48 | ## Callbacks
49 | ## ---------
50 |
51 |
52 | # Initialize State
53 | @doc false
54 | def init(:ok) do
55 | # Create Connection & Channel
56 | {:ok, connection} = AMQP.Connection.open
57 | {:ok, channel} = AMQP.Channel.open(connection)
58 |
59 | # Declare Exchange & Queue
60 | AMQP.Exchange.declare(channel, @exchange, :direct)
61 | AMQP.Queue.declare(channel, @queue, durable: false)
62 | AMQP.Queue.bind(channel, @queue, @exchange, routing_key: @queue)
63 |
64 | # Start Consuming
65 | AMQP.Basic.consume(channel, @queue, nil, no_ack: true)
66 |
67 | {:ok, channel}
68 | end
69 |
70 |
71 |
72 | # Receive Messages
73 | @doc false
74 | def handle_info({:basic_deliver, payload, meta}, channel) do
75 | Logger.debug("Received Payload: #{inspect payload}")
76 |
77 | spawn fn ->
78 | consume(channel, payload, meta)
79 | end
80 |
81 | {:noreply, channel}
82 | end
83 |
84 |
85 |
86 | # Discard all other messages
87 | @doc false
88 | def handle_info(message, state) do
89 | Logger.debug("Received info: #{inspect message}")
90 | {:noreply, state}
91 | end
92 |
93 |
94 |
95 |
96 |
97 | ## Private Helpers
98 | ## ---------------
99 |
100 |
101 | # Consume RPC calls and respond accordingly
102 | defp consume(channel, command, %{type: "rpc"} = meta) do
103 | Logger.debug("Message Type: RPC Call")
104 |
105 | case command do
106 | "all" ->
107 | payload = Poison.encode!(Todo.all)
108 | rpc_reply!(channel, meta, payload)
109 |
110 | _ ->
111 | raise "Unknown RPC Command: #{inspect(command)}"
112 | end
113 | end
114 |
115 |
116 | # Consume event messages and perform appropriate actions
117 | defp consume(_channel, payload, %{type: "event"}) do
118 | Logger.debug("Message Type: Event Dispatch")
119 | %Event{type: type, data: data} = Event.decode!(payload)
120 |
121 | case type do
122 | :insert ->
123 | Todo.insert(data)
124 |
125 | :update ->
126 | Todo.update(data.id, data)
127 |
128 | :delete ->
129 | Todo.delete(data.id)
130 |
131 | _ ->
132 | raise "Don't know how to perform operation #{inspect(type)}"
133 | end
134 |
135 | rescue
136 | Event.InvalidError ->
137 | raise "Received invalid event data #{inspect(payload)}"
138 | end
139 |
140 |
141 | # Handle unknown message types
142 | defp consume(_channel, _payload, meta) do
143 | Logger.error("Unknown Message Type. Supplied Metadata: #{inspect(meta)}")
144 | end
145 |
146 |
147 | # Respond to an RPC call
148 | defp rpc_reply!(channel, meta, response) do
149 | AMQP.Basic.publish(
150 | channel,
151 | @rpc,
152 | meta.reply_to,
153 | response,
154 | correlation_id: meta.correlation_id
155 | )
156 | rescue
157 | _ -> raise "Could not reply to RPC request: #{inspect(meta)}"
158 | end
159 |
160 |
161 | end
162 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ZTD
2 | ===
3 |
4 | [![Build Status][shield-travis]][travis-ci]
5 | [![License][shield-license]][github]
6 |
7 | > Todo App written in Elixir/Phoenix using RabbitMQ
8 |
9 | This is a small experiment using RabbitMQ. The app is designed to be run in
10 | one of two modes; `Engine` and `Worker`. When run in Engine mode, the app
11 | stores and reads items from disk. When run in Worker mode, the app doesn't
12 | have it's own state, instead it listens to events from the engine and
13 | dispatches events to it when actions are performed.
14 |
15 | **Demo:**
16 |
17 | [![ZTD Demo Video][demo-thumb]][demo-video]
18 |
19 |
);
127 | }
128 |
129 |
130 | render() {
131 | const {items} = this.state;
132 | const {mode} = this.props;
133 |
134 | return (
135 |
136 |
137 | App Mode: {mode}Socket: {this.renderStatus()}
140 |
141 |
142 |
145 |
146 |
147 | { items.map(i =>
148 |
155 |
156 | {this.renderWall()}
157 |
158 |