├── .tool-versions
├── .github
    └── FUNDING.yml
├── test
    ├── test_helper.exs
    ├── docker_elixir_19_release_web
    │   ├── views
    │   │   ├── page_view_test.exs
    │   │   ├── layout_view_test.exs
    │   │   └── error_view_test.exs
    │   └── controllers
    │   │   └── page_controller_test.exs
    └── support
    │   ├── channel_case.ex
    │   └── conn_case.ex
├── .formatter.exs
├── lib
    ├── docker_elixir_19_release_web
    │   ├── views
    │   │   ├── page_view.ex
    │   │   ├── layout_view.ex
    │   │   ├── error_view.ex
    │   │   └── error_helpers.ex
    │   ├── controllers
    │   │   └── page_controller.ex
    │   ├── router.ex
    │   ├── gettext.ex
    │   ├── channels
    │   │   └── user_socket.ex
    │   ├── templates
    │   │   ├── page
    │   │   │   └── index.html.eex
    │   │   └── layout
    │   │   │   └── app.html.eex
    │   └── endpoint.ex
    ├── docker_elixir_19_release.ex
    ├── docker_elixir_19_release
    │   └── application.ex
    └── docker_elixir_19_release_web.ex
├── rel
    ├── env.bat.eex
    ├── vm.args.eex
    └── env.sh.eex
├── config
    ├── test.exs
    ├── releases.exs
    ├── config.exs
    ├── dev.exs
    └── prod.exs
├── priv
    └── gettext
    │   ├── en
    │       └── LC_MESSAGES
    │       │   └── errors.po
    │   └── errors.pot
├── README.md
├── .gitignore
├── mix.exs
├── Dockerfile
└── mix.lock


/.tool-versions:
--------------------------------------------------------------------------------
1 | elixir 1.9.0-rc.0
2 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [akoutmos]
2 | 


--------------------------------------------------------------------------------
/test/test_helper.exs:
--------------------------------------------------------------------------------
1 | ExUnit.start()
2 | 


--------------------------------------------------------------------------------
/.formatter.exs:
--------------------------------------------------------------------------------
1 | [
2 |   import_deps: [:phoenix],
3 |   inputs: ["*.{ex,exs}", "{config,lib,test}/**/*.{ex,exs}"]
4 | ]
5 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/views/page_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DockerElixir19ReleaseWeb.PageView do
2 |   use DockerElixir19ReleaseWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/views/layout_view.ex:
--------------------------------------------------------------------------------
1 | defmodule DockerElixir19ReleaseWeb.LayoutView do
2 |   use DockerElixir19ReleaseWeb, :view
3 | end
4 | 


--------------------------------------------------------------------------------
/rel/env.bat.eex:
--------------------------------------------------------------------------------
1 | @echo off
2 | rem Set the release to work across nodes
3 | rem set RELEASE_DISTRIBUTION=name
4 | rem set RELEASE_NODE=<%= @release.name %>@127.0.0.1
5 | 


--------------------------------------------------------------------------------
/test/docker_elixir_19_release_web/views/page_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DockerElixir19ReleaseWeb.PageViewTest do
2 |   use DockerElixir19ReleaseWeb.ConnCase, async: true
3 | end
4 | 


--------------------------------------------------------------------------------
/test/docker_elixir_19_release_web/views/layout_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DockerElixir19ReleaseWeb.LayoutViewTest do
2 |   use DockerElixir19ReleaseWeb.ConnCase, async: true
3 | end
4 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/controllers/page_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule DockerElixir19ReleaseWeb.PageController do
2 |   use DockerElixir19ReleaseWeb, :controller
3 | 
4 |   def index(conn, _params) do
5 |     render(conn, "index.html")
6 |   end
7 | end
8 | 


--------------------------------------------------------------------------------
/test/docker_elixir_19_release_web/controllers/page_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule DockerElixir19ReleaseWeb.PageControllerTest do
2 |   use DockerElixir19ReleaseWeb.ConnCase
3 | 
4 |   test "GET /", %{conn: conn} do
5 |     conn = get(conn, "/")
6 |     assert html_response(conn, 200) =~ "Welcome to Phoenix!"
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19Release do
 2 |   @moduledoc """
 3 |   DockerElixir19Release 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 | 


--------------------------------------------------------------------------------
/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 :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
 6 |   http: [port: 4002],
 7 |   server: false
 8 | 
 9 | # Print only warnings and errors during test
10 | config :logger, level: :warn
11 | 


--------------------------------------------------------------------------------
/rel/vm.args.eex:
--------------------------------------------------------------------------------
 1 | ## Customize flags given to the VM: http://erlang.org/doc/man/erl.html
 2 | ## -mode/-name/-sname/-setcookie are configured via env vars, do not set them here
 3 | 
 4 | ## Number of dirty schedulers doing IO work (file, sockets, etc)
 5 | ##+SDio 5
 6 | 
 7 | ## Increase number of concurrent ports/sockets
 8 | ##+Q 65536
 9 | 
10 | ## Tweak GC to run more often
11 | ##-env ERL_FULLSWEEP_AFTER 10
12 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/priv/gettext/errors.pot:
--------------------------------------------------------------------------------
 1 | ## This 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 has no
 9 | ## effect: edit them in PO (`.po`) files instead.
10 | 
11 | 


--------------------------------------------------------------------------------
/config/releases.exs:
--------------------------------------------------------------------------------
 1 | import Config
 2 | 
 3 | secret_key_base = System.fetch_env!("SECRET_KEY_BASE")
 4 | cool_text = System.fetch_env!("COOL_TEXT")
 5 | application_port = System.fetch_env!("APP_PORT")
 6 | 
 7 | config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
 8 |   http: [:inet6, port: String.to_integer(application_port)],
 9 |   secret_key_base: secret_key_base
10 | 
11 | config :docker_elixir_19_release,
12 |   cool_text: cool_text
13 | 


--------------------------------------------------------------------------------
/rel/env.sh.eex:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Sets and enables heart (recommended only in daemon mode)
 4 | # if [ "$RELEASE_COMMAND" = "daemon" ] || [ "$RELEASE_COMMAND" = "daemon_iex" ]; then
 5 | #   HEART_COMMAND="$RELEASE_ROOT/bin/$RELEASE_NAME $RELEASE_COMMAND"
 6 | #   export HEART_COMMAND
 7 | #   export ELIXIR_ERL_OPTIONS="-heart"
 8 | # fi
 9 | 
10 | # Set the release to work across nodes
11 | # export RELEASE_DISTRIBUTION=name
12 | # export RELEASE_NODE=<%= @release.name %>@127.0.0.1
13 | 


--------------------------------------------------------------------------------
/test/docker_elixir_19_release_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.ErrorViewTest do
 2 |   use DockerElixir19ReleaseWeb.ConnCase, async: true
 3 | 
 4 |   # Bring render/3 and render_to_string/3 for testing custom views
 5 |   import Phoenix.View
 6 | 
 7 |   test "renders 404.html" do
 8 |     assert render_to_string(DockerElixir19ReleaseWeb.ErrorView, "404.html", []) == "Not Found"
 9 |   end
10 | 
11 |   test "renders 500.html" do
12 |     assert render_to_string(DockerElixir19ReleaseWeb.ErrorView, "500.html", []) == "Internal Server Error"
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/views/error_view.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.ErrorView do
 2 |   use DockerElixir19ReleaseWeb, :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/docker_elixir_19_release_web/router.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.Router do
 2 |   use DockerElixir19ReleaseWeb, :router
 3 | 
 4 |   pipeline :browser do
 5 |     plug :accepts, ["html"]
 6 |     plug :fetch_session
 7 |     plug :fetch_flash
 8 |     plug :protect_from_forgery
 9 |     plug :put_secure_browser_headers
10 |   end
11 | 
12 |   pipeline :api do
13 |     plug :accepts, ["json"]
14 |   end
15 | 
16 |   scope "/", DockerElixir19ReleaseWeb do
17 |     pipe_through :browser
18 | 
19 |     get "/", PageController, :index
20 |   end
21 | 
22 |   # Other scopes may use custom stacks.
23 |   # scope "/api", DockerElixir19ReleaseWeb do
24 |   #   pipe_through :api
25 |   # end
26 | end
27 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DockerElixir19Release
 2 | 
 3 | To start your Phoenix server:
 4 | 
 5 |   * Install dependencies with `mix deps.get`
 6 |   * Start Phoenix endpoint with `mix phx.server`
 7 | 
 8 | Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.
 9 | 
10 | Ready to run in production? Please [check our deployment guides](https://hexdocs.pm/phoenix/deployment.html).
11 | 
12 | ## Learn more
13 | 
14 |   * Official website: http://www.phoenixframework.org/
15 |   * Guides: https://hexdocs.pm/phoenix/overview.html
16 |   * Docs: https://hexdocs.pm/phoenix
17 |   * Mailing list: http://groups.google.com/group/phoenix-talk
18 |   * Source: https://github.com/phoenixframework/phoenix
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # The directory Mix will write compiled artifacts to.
 2 | /_build/
 3 | 
 4 | # If you run "mix test --cover", coverage assets end up here.
 5 | /cover/
 6 | 
 7 | # The directory Mix downloads your dependencies sources to.
 8 | /deps/
 9 | 
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 | 
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 | 
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 | 
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 | 
22 | # Ignore package tarball (built via "mix hex.build").
23 | docker_elixir_19_release-*.tar
24 | 
25 | # Since we are building assets from assets/,
26 | # we ignore priv/static. You may want to comment
27 | # this depending on your deployment strategy.
28 | /priv/static/
29 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/gettext.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.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 DockerElixir19ReleaseWeb.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: :docker_elixir_19_release
24 | end
25 | 


--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.ChannelCase do
 2 |   @moduledoc """
 3 |   This module defines the test case to be used by
 4 |   channel tests.
 5 | 
 6 |   Such tests rely on `Phoenix.ChannelTest` and also
 7 |   import other functionality to make it easier
 8 |   to build common data structures and query the data layer.
 9 | 
10 |   Finally, if the test case interacts with the database,
11 |   it cannot be async. For this reason, every test runs
12 |   inside a transaction which is reset at the beginning
13 |   of the test unless the test case is marked as async.
14 |   """
15 | 
16 |   use ExUnit.CaseTemplate
17 | 
18 |   using do
19 |     quote do
20 |       # Import conveniences for testing with channels
21 |       use Phoenix.ChannelTest
22 | 
23 |       # The default endpoint for testing
24 |       @endpoint DockerElixir19ReleaseWeb.Endpoint
25 |     end
26 |   end
27 | 
28 |   setup _tags do
29 |     :ok
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/test/support/conn_case.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.ConnCase do
 2 |   @moduledoc """
 3 |   This module defines the test case to be used by
 4 |   tests that require setting up a connection.
 5 | 
 6 |   Such tests rely on `Phoenix.ConnTest` and also
 7 |   import other functionality to make it easier
 8 |   to build common data structures and query the data layer.
 9 | 
10 |   Finally, if the test case interacts with the database,
11 |   it cannot be async. For this reason, every test runs
12 |   inside a transaction which is reset at the beginning
13 |   of the test unless the test case is marked as async.
14 |   """
15 | 
16 |   use ExUnit.CaseTemplate
17 | 
18 |   using do
19 |     quote do
20 |       # Import conveniences for testing with connections
21 |       use Phoenix.ConnTest
22 |       alias DockerElixir19ReleaseWeb.Router.Helpers, as: Routes
23 | 
24 |       # The default endpoint for testing
25 |       @endpoint DockerElixir19ReleaseWeb.Endpoint
26 |     end
27 |   end
28 | 
29 |   setup _tags do
30 |     {:ok, conn: Phoenix.ConnTest.build_conn()}
31 |   end
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release/application.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19Release.Application do
 2 |   # See https://hexdocs.pm/elixir/Application.html
 3 |   # for more information on OTP Applications
 4 |   @moduledoc false
 5 | 
 6 |   use Application
 7 | 
 8 |   def start(_type, _args) do
 9 |     # List all child processes to be supervised
10 |     children = [
11 |       # Start the endpoint when the application starts
12 |       DockerElixir19ReleaseWeb.Endpoint
13 |       # Starts a worker by calling: DockerElixir19Release.Worker.start_link(arg)
14 |       # {DockerElixir19Release.Worker, arg},
15 |     ]
16 | 
17 |     # See https://hexdocs.pm/elixir/Supervisor.html
18 |     # for other strategies and supported options
19 |     opts = [strategy: :one_for_one, name: DockerElixir19Release.Supervisor]
20 |     Supervisor.start_link(children, opts)
21 |   end
22 | 
23 |   # Tell Phoenix to update the endpoint configuration
24 |   # whenever the application is updated.
25 |   def config_change(changed, _new, removed) do
26 |     DockerElixir19ReleaseWeb.Endpoint.config_change(changed, removed)
27 |     :ok
28 |   end
29 | end
30 | 


--------------------------------------------------------------------------------
/config/config.exs:
--------------------------------------------------------------------------------
 1 | # This file is responsible for configuring your application
 2 | # and its dependencies with the aid of the Mix.Config module.
 3 | #
 4 | # This configuration file is loaded before any dependency and
 5 | # is restricted to this project.
 6 | 
 7 | # General application configuration
 8 | use Mix.Config
 9 | 
10 | # Configures the endpoint
11 | config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
12 |   url: [host: "localhost"],
13 |   secret_key_base: "6Alpv/H1mEDDJAEarC1QwZ2mIqXZXEhpERpfP80YU6m0N16mxAd73taFlBYaSU5K",
14 |   render_errors: [view: DockerElixir19ReleaseWeb.ErrorView, accepts: ~w(html json)],
15 |   pubsub: [name: DockerElixir19Release.PubSub, adapter: Phoenix.PubSub.PG2]
16 | 
17 | # Configures Elixir's Logger
18 | config :logger, :console,
19 |   format: "$time $metadata[$level] $message\n",
20 |   metadata: [:request_id]
21 | 
22 | # Use Jason for JSON parsing in Phoenix
23 | config :phoenix, :json_library, Jason
24 | 
25 | # Import environment specific config. This must remain at the bottom
26 | # of this file so it overrides the configuration defined above.
27 | import_config "#{Mix.env()}.exs"
28 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.UserSocket do
 2 |   use Phoenix.Socket
 3 | 
 4 |   ## Channels
 5 |   # channel "room:*", DockerElixir19ReleaseWeb.RoomChannel
 6 | 
 7 |   # Socket params are passed from the client and can
 8 |   # be used to verify and authenticate a user. After
 9 |   # verification, you can put default assigns into
10 |   # the socket that will be set for all channels, ie
11 |   #
12 |   #     {:ok, assign(socket, :user_id, verified_user_id)}
13 |   #
14 |   # To deny connection, return `:error`.
15 |   #
16 |   # See `Phoenix.Token` documentation for examples in
17 |   # performing token verification on connect.
18 |   def connect(_params, socket, _connect_info) do
19 |     {:ok, socket}
20 |   end
21 | 
22 |   # Socket id's are topics that allow you to identify all sockets for a given user:
23 |   #
24 |   #     def id(socket), do: "user_socket:#{socket.assigns.user_id}"
25 |   #
26 |   # Would allow you to broadcast a "disconnect" event and terminate
27 |   # all active sockets and channels for a given user:
28 |   #
29 |   #     DockerElixir19ReleaseWeb.Endpoint.broadcast("user_socket:#{user.id}", "disconnect", %{})
30 |   #
31 |   # Returning `nil` makes this socket anonymous.
32 |   def id(_socket), do: nil
33 | end
34 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/templates/page/index.html.eex:
--------------------------------------------------------------------------------
 1 | <section class="phx-hero">
 2 |   <h1><%= gettext "Welcome to %{name}!", name: "Phoenix" %></h1>
 3 |   <p>A productive web framework that<br/>does not compromise speed or maintainability.</p>
 4 |   <p><%= Application.get_env(:docker_elixir_19_release, :cool_text) %></p>
 5 | </section>
 6 | 
 7 | <section class="row">
 8 |   <article class="column">
 9 |     <h2>Resources</h2>
10 |     <ul>
11 |       <li>
12 |         <a href="https://hexdocs.pm/phoenix/overview.html">Guides &amp; Docs</a>
13 |       </li>
14 |       <li>
15 |         <a href="https://github.com/phoenixframework/phoenix">Source</a>
16 |       </li>
17 |       <li>
18 |         <a href="https://github.com/phoenixframework/phoenix/blob/v1.4/CHANGELOG.md">v1.4 Changelog</a>
19 |       </li>
20 |     </ul>
21 |   </article>
22 |   <article class="column">
23 |     <h2>Help</h2>
24 |     <ul>
25 |       <li>
26 |         <a href="https://elixirforum.com/c/phoenix-forum">Forum</a>
27 |       </li>
28 |       <li>
29 |         <a href="https://webchat.freenode.net/?channels=elixir-lang">#elixir-lang on Freenode IRC</a>
30 |       </li>
31 |       <li>
32 |         <a href="https://twitter.com/elixirphoenix">Twitter @elixirphoenix</a>
33 |       </li>
34 |     </ul>
35 |   </article>
36 | </section>
37 | 


--------------------------------------------------------------------------------
/mix.exs:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19Release.MixProject do
 2 |   use Mix.Project
 3 | 
 4 |   def project do
 5 |     [
 6 |       app: :docker_elixir_19_release,
 7 |       version: "0.1.0",
 8 |       elixir: "~> 1.5",
 9 |       elixirc_paths: elixirc_paths(Mix.env()),
10 |       compilers: [:phoenix, :gettext] ++ Mix.compilers(),
11 |       start_permanent: Mix.env() == :prod,
12 |       deps: deps()
13 |     ]
14 |   end
15 | 
16 |   # Configuration for the OTP application.
17 |   #
18 |   # Type `mix help compile.app` for more information.
19 |   def application do
20 |     [
21 |       mod: {DockerElixir19Release.Application, []},
22 |       extra_applications: [:logger, :runtime_tools]
23 |     ]
24 |   end
25 | 
26 |   # Specifies which paths to compile per environment.
27 |   defp elixirc_paths(:test), do: ["lib", "test/support"]
28 |   defp elixirc_paths(_), do: ["lib"]
29 | 
30 |   # Specifies your project dependencies.
31 |   #
32 |   # Type `mix help deps` for examples and options.
33 |   defp deps do
34 |     [
35 |       {:phoenix, "~> 1.4.7"},
36 |       {:phoenix_pubsub, "~> 1.1"},
37 |       {:phoenix_html, "~> 2.11"},
38 |       {:phoenix_live_reload, "~> 1.2", only: :dev},
39 |       {:gettext, "~> 0.11"},
40 |       {:jason, "~> 1.0"},
41 |       {:plug_cowboy, "~> 2.0"},
42 |       {:observer_cli, "~> 1.5"}
43 |     ]
44 |   end
45 | end
46 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/templates/layout/app.html.eex:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="utf-8"/>
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
 7 |     <title>DockerElixir19Release · Phoenix Framework</title>
 8 |     <link rel="stylesheet" href="<%= Routes.static_path(@conn, "/css/app.css") %>"/>
 9 |   </head>
10 |   <body>
11 |     <header>
12 |       <section class="container">
13 |         <nav role="navigation">
14 |           <ul>
15 |             <li><a href="https://hexdocs.pm/phoenix/overview.html">Get Started</a></li>
16 |           </ul>
17 |         </nav>
18 |         <a href="http://phoenixframework.org/" class="phx-logo">
19 |           <img src="<%= Routes.static_path(@conn, "/images/phoenix.png") %>" alt="Phoenix Framework Logo"/>
20 |         </a>
21 |       </section>
22 |     </header>
23 |     <main role="main" class="container">
24 |       <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
25 |       <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
26 |       <%= render @view_module, @view_template, assigns %>
27 |     </main>
28 |     <script type="text/javascript" src="<%= Routes.static_path(@conn, "/js/app.js") %>"></script>
29 |   </body>
30 | </html>
31 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/endpoint.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.Endpoint do
 2 |   use Phoenix.Endpoint, otp_app: :docker_elixir_19_release
 3 | 
 4 |   socket "/socket", DockerElixir19ReleaseWeb.UserSocket,
 5 |     websocket: true,
 6 |     longpoll: false
 7 | 
 8 |   # Serve at "/" the static files from "priv/static" directory.
 9 |   #
10 |   # You should set gzip to true if you are running phx.digest
11 |   # when deploying your static files in production.
12 |   plug Plug.Static,
13 |     at: "/",
14 |     from: :docker_elixir_19_release,
15 |     gzip: false,
16 |     only: ~w(css fonts images js favicon.ico robots.txt)
17 | 
18 |   # Code reloading can be explicitly enabled under the
19 |   # :code_reloader configuration of your endpoint.
20 |   if code_reloading? do
21 |     socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket
22 |     plug Phoenix.LiveReloader
23 |     plug Phoenix.CodeReloader
24 |   end
25 | 
26 |   plug Plug.RequestId
27 |   plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]
28 | 
29 |   plug Plug.Parsers,
30 |     parsers: [:urlencoded, :multipart, :json],
31 |     pass: ["*/*"],
32 |     json_decoder: Phoenix.json_library()
33 | 
34 |   plug Plug.MethodOverride
35 |   plug Plug.Head
36 | 
37 |   # The session will be stored in the cookie and signed,
38 |   # this means its contents can be read but not tampered with.
39 |   # Set :encryption_salt if you would also like to encrypt it.
40 |   plug Plug.Session,
41 |     store: :cookie,
42 |     key: "_docker_elixir_19_release_key",
43 |     signing_salt: "N9h5zeCE"
44 | 
45 |   plug DockerElixir19ReleaseWeb.Router
46 | end
47 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web/views/error_helpers.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb.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(DockerElixir19ReleaseWeb.Gettext, "errors", msg, msg, count, opts)
40 |     else
41 |       Gettext.dgettext(DockerElixir19ReleaseWeb.Gettext, "errors", msg, opts)
42 |     end
43 |   end
44 | end
45 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # ---- Build Stage ----
 2 | FROM erlang:21 AS app_builder
 3 | 
 4 | # Set environment variables for building the application
 5 | ENV MIX_ENV=prod \
 6 |     TEST=1 \
 7 |     LANG=C.UTF-8
 8 | 
 9 | # Fetch the latest version of Elixir (once the 1.9 docker image is available you won't have to do this)
10 | RUN set -xe \
11 |   && ELIXIR_DOWNLOAD_URL="https://github.com/elixir-lang/elixir/archive/v1.9.0-rc.0.tar.gz" \
12 |   && ELIXIR_DOWNLOAD_SHA256="fa019ba18556f53bfb77840b0970afd116517764251704b55e419becb0b384cf" \
13 |   && curl -fSL -o elixir-src.tar.gz $ELIXIR_DOWNLOAD_URL \
14 |   && echo "$ELIXIR_DOWNLOAD_SHA256  elixir-src.tar.gz" | sha256sum -c - \
15 |   && mkdir -p /usr/local/src/elixir \
16 |   && tar -xzC /usr/local/src/elixir --strip-components=1 -f elixir-src.tar.gz \
17 |   && rm elixir-src.tar.gz \
18 |   && cd /usr/local/src/elixir \
19 |   && make install clean
20 | 
21 | # Install hex and rebar
22 | RUN mix local.hex --force && \
23 |     mix local.rebar --force
24 | 
25 | # Create the application build directory
26 | RUN mkdir /app
27 | WORKDIR /app
28 | 
29 | # Copy over all the necessary application files and directories
30 | COPY config ./config
31 | COPY lib ./lib
32 | COPY priv ./priv
33 | COPY mix.exs .
34 | COPY mix.lock .
35 | 
36 | # Fetch the application dependencies and build the application
37 | RUN mix deps.get
38 | RUN mix deps.compile
39 | RUN mix phx.digest
40 | RUN mix release
41 | 
42 | # ---- Application Stage ----
43 | FROM debian:stretch AS app
44 | 
45 | ENV LANG=C.UTF-8
46 | 
47 | # Install openssl
48 | RUN apt-get update && apt-get install -y openssl
49 | 
50 | # Copy over the build artifact from the previous step and create a non root user
51 | RUN useradd --create-home app
52 | WORKDIR /home/app
53 | COPY --from=app_builder /app/_build .
54 | RUN chown -R app: ./prod
55 | USER app
56 | 
57 | # Run the Phoenix app
58 | CMD ["./prod/rel/docker_elixir_19_release/bin/docker_elixir_19_release", "start"]
59 | 


--------------------------------------------------------------------------------
/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 webpack to recompile .js and .css sources.
 9 | config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
10 |   http: [port: 4000],
11 |   debug_errors: true,
12 |   code_reloader: true,
13 |   check_origin: false,
14 |   watchers: []
15 | 
16 | # ## SSL Support
17 | #
18 | # In order to use HTTPS in development, a self-signed
19 | # certificate can be generated by running the following
20 | # Mix task:
21 | #
22 | #     mix phx.gen.cert
23 | #
24 | # Note that this task requires Erlang/OTP 20 or later.
25 | # Run `mix help phx.gen.cert` for more information.
26 | #
27 | # The `http:` config above can be replaced with:
28 | #
29 | #     https: [
30 | #       port: 4001,
31 | #       cipher_suite: :strong,
32 | #       keyfile: "priv/cert/selfsigned_key.pem",
33 | #       certfile: "priv/cert/selfsigned.pem"
34 | #     ],
35 | #
36 | # If desired, both `http:` and `https:` keys can be
37 | # configured to run both http and https servers on
38 | # different ports.
39 | 
40 | # Watch static and templates for browser reloading.
41 | config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
42 |   live_reload: [
43 |     patterns: [
44 |       ~r"priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$",
45 |       ~r"priv/gettext/.*(po)$",
46 |       ~r"lib/docker_elixir_19_release_web/{live,views}/.*(ex)$",
47 |       ~r"lib/docker_elixir_19_release_web/templates/.*(eex)$"
48 |     ]
49 |   ]
50 | 
51 | # Do not include metadata nor timestamps in development logs
52 | config :logger, :console, format: "[$level] $message\n"
53 | 
54 | # Set a higher stacktrace during development. Avoid configuring such
55 | # in production as building large stacktraces may be expensive.
56 | config :phoenix, :stacktrace_depth, 20
57 | 
58 | # Initialize plugs at runtime for faster development compilation
59 | config :phoenix, :plug_init_mode, :runtime
60 | 


--------------------------------------------------------------------------------
/lib/docker_elixir_19_release_web.ex:
--------------------------------------------------------------------------------
 1 | defmodule DockerElixir19ReleaseWeb 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 DockerElixir19ReleaseWeb, :controller
 9 |       use DockerElixir19ReleaseWeb, :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 |   def controller do
21 |     quote do
22 |       use Phoenix.Controller, namespace: DockerElixir19ReleaseWeb
23 | 
24 |       import Plug.Conn
25 |       import DockerElixir19ReleaseWeb.Gettext
26 |       alias DockerElixir19ReleaseWeb.Router.Helpers, as: Routes
27 |     end
28 |   end
29 | 
30 |   def view do
31 |     quote do
32 |       use Phoenix.View,
33 |         root: "lib/docker_elixir_19_release_web/templates",
34 |         namespace: DockerElixir19ReleaseWeb
35 | 
36 |       # Import convenience functions from controllers
37 |       import Phoenix.Controller, only: [get_flash: 1, get_flash: 2, view_module: 1]
38 | 
39 |       # Use all HTML functionality (forms, tags, etc)
40 |       use Phoenix.HTML
41 | 
42 |       import DockerElixir19ReleaseWeb.ErrorHelpers
43 |       import DockerElixir19ReleaseWeb.Gettext
44 |       alias DockerElixir19ReleaseWeb.Router.Helpers, as: Routes
45 |     end
46 |   end
47 | 
48 |   def router do
49 |     quote do
50 |       use Phoenix.Router
51 |       import Plug.Conn
52 |       import Phoenix.Controller
53 |     end
54 |   end
55 | 
56 |   def channel do
57 |     quote do
58 |       use Phoenix.Channel
59 |       import DockerElixir19ReleaseWeb.Gettext
60 |     end
61 |   end
62 | 
63 |   @doc """
64 |   When used, dispatch to the appropriate controller/view/etc.
65 |   """
66 |   defmacro __using__(which) when is_atom(which) do
67 |     apply(__MODULE__, which, [])
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/config/prod.exs:
--------------------------------------------------------------------------------
 1 | use Mix.Config
 2 | 
 3 | # For production, don't forget to configure the url host
 4 | # to something meaningful, Phoenix uses this information
 5 | # when generating URLs.
 6 | #
 7 | # Note we also include the path to a cache manifest
 8 | # containing the digested version of static files. This
 9 | # manifest is generated by the `mix phx.digest` task,
10 | # which you should run after static files are built and
11 | # before starting your production server.
12 | config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
13 |   url: [host: "example.com", port: 80],
14 |   cache_static_manifest: "priv/static/cache_manifest.json"
15 | 
16 | # Do not print debug messages in production
17 | config :logger, level: :info
18 | 
19 | # ## SSL Support
20 | #
21 | # To get SSL working, you will need to add the `https` key
22 | # to the previous section and set your `:url` port to 443:
23 | #
24 | #     config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
25 | #       ...
26 | #       url: [host: "example.com", port: 443],
27 | #       https: [
28 | #         :inet6,
29 | #         port: 443,
30 | #         cipher_suite: :strong,
31 | #         keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
32 | #         certfile: System.get_env("SOME_APP_SSL_CERT_PATH")
33 | #       ]
34 | #
35 | # The `cipher_suite` is set to `:strong` to support only the
36 | # latest and more secure SSL ciphers. This means old browsers
37 | # and clients may not be supported. You can set it to
38 | # `:compatible` for wider support.
39 | #
40 | # `:keyfile` and `:certfile` expect an absolute path to the key
41 | # and cert in disk or a relative path inside priv, for example
42 | # "priv/ssl/server.key". For all supported SSL configuration
43 | # options, see https://hexdocs.pm/plug/Plug.SSL.html#configure/1
44 | #
45 | # We also recommend setting `force_ssl` in your endpoint, ensuring
46 | # no data is ever sent via http, always redirecting to https:
47 | #
48 | #     config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint,
49 | #       force_ssl: [hsts: true]
50 | #
51 | # Check `Plug.SSL` for all available options in `force_ssl`.
52 | 
53 | # ## Using releases (Elixir v1.9+)
54 | #
55 | # If you are doing OTP releases, you need to instruct Phoenix
56 | # to start each relevant endpoint:
57 | #
58 | config :docker_elixir_19_release, DockerElixir19ReleaseWeb.Endpoint, server: true
59 | #
60 | # Then you can assemble a release by calling `mix release`.
61 | # See `mix help release` for more information.
62 | 
63 | # Finally import the config/prod.secret.exs which loads secrets
64 | # and configuration from environment variables.
65 | 


--------------------------------------------------------------------------------
/mix.lock:
--------------------------------------------------------------------------------
 1 | %{
 2 |   "cowboy": {:hex, :cowboy, "2.6.3", "99aa50e94e685557cad82e704457336a453d4abcb77839ad22dbe71f311fcc06", [:rebar3], [{:cowlib, "~> 2.7.3", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "~> 1.7.1", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm"},
 3 |   "cowlib": {:hex, :cowlib, "2.7.3", "a7ffcd0917e6d50b4d5fb28e9e2085a0ceb3c97dea310505f7460ff5ed764ce9", [:rebar3], [], "hexpm"},
 4 |   "file_system": {:hex, :file_system, "0.2.7", "e6f7f155970975789f26e77b8b8d8ab084c59844d8ecfaf58cbda31c494d14aa", [:mix], [], "hexpm"},
 5 |   "gettext": {:hex, :gettext, "0.16.1", "e2130b25eebcbe02bb343b119a07ae2c7e28bd4b146c4a154da2ffb2b3507af2", [:mix], [], "hexpm"},
 6 |   "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
 7 |   "mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm"},
 8 |   "phoenix": {:hex, :phoenix, "1.4.8", "c72dc3adeb49c70eb963a0ea24f7a064ec1588e651e84e1b7ad5ed8253c0b4a2", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
 9 |   "phoenix_html": {:hex, :phoenix_html, "2.13.3", "850e292ff6e204257f5f9c4c54a8cb1f6fbc16ed53d360c2b780a3d0ba333867", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
10 |   "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.2.1", "274a4b07c4adbdd7785d45a8b0bb57634d0b4f45b18d2c508b26c0344bd59b8f", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm"},
11 |   "phoenix_pubsub": {:hex, :phoenix_pubsub, "1.1.2", "496c303bdf1b2e98a9d26e89af5bba3ab487ba3a3735f74bf1f4064d2a845a3e", [:mix], [], "hexpm"},
12 |   "plug": {:hex, :plug, "1.8.2", "0bcce1daa420f189a6491f3940cc77ea7fb1919761175c9c3b59800d897440fc", [:mix], [{:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm"},
13 |   "plug_cowboy": {:hex, :plug_cowboy, "2.0.2", "6055f16868cc4882b24b6e1d63d2bada94fb4978413377a3b32ac16c18dffba2", [:mix], [{:cowboy, "~> 2.5", [hex: :cowboy, repo: "hexpm", optional: false]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
14 |   "plug_crypto": {:hex, :plug_crypto, "1.0.0", "18e49317d3fa343f24620ed22795ec29d4a5e602d52d1513ccea0b07d8ea7d4d", [:mix], [], "hexpm"},
15 |   "ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm"},
16 |   "telemetry": {:hex, :telemetry, "0.4.0", "8339bee3fa8b91cb84d14c2935f8ecf399ccd87301ad6da6b71c09553834b2ab", [:rebar3], [], "hexpm"},
17 | }
18 | 


--------------------------------------------------------------------------------