Embed

@chris_mccord

ElixirConf July 26, 2014

littlelines.com

Phoenix

Why?
Goals
Main Features

Robust routing
WebSocket / PubSub layer (client & server)
Plug-based Routers & Controllers
Precompiled View layer

The Future

Why?

"Elixir Web Framework targeting full-featured, fault tolerant applications with realtime functionality"

Why Elixir?

"What if I could just..." Driven Development

Metaprogramming
Fault Tolerance
Concurrency
Distribution

"Web" Framework Goals

"Distributed Web Services" framework
Batteries Included
Shared Conventions
Common tasks should be easy

WebSockets
Realtime events
SOA

No productivity sacrifices for performance
No performance sacrifices for productivity

Routing

defmodule App.Router do
  use Phoenix.Router

  get "/pages/:slug", App.PageController, :show, as: :page
  get "/files/*path", App.FileController, :show

  resources "users", App.UserController do
    resources "comments", App.CommentController
  end

  scope path: "admin", alias: App.Admin, helper: "admin" do
    resources "users", UserController
  end
end

defmodule App.Router do
  def match(conn, "GET",    ["pages", slug])
  def match(conn, "GET",    ["files" | path])
  def match(conn, "GET",    ["users"])
  def match(conn, "GET",    ["users", id, "edit"])
  def match(conn, "GET",    ["users", id])
  def match(conn, "GET",    ["users", "new"])
  def match(conn, "POST",   ["users"])
  def match(conn, "PUT",    ["users", id])
  def match(conn, "PATCH",  ["users", id])
  def match(conn, "DELETE", ["users", id])
  def match(conn, "GET",    ["users", user_id, "comments"])
  def match(conn, "GET",    ["users", user_id, "comments", id, "edit"])
  def match(conn, "GET",    ["users", user_id, "comments", id])

  def match(conn, "GET",    ["users", user_id, "comments", "new"])
  def match(conn, "POST",   ["users", user_id, "comments"])
  def match(conn, "PUT",    ["users", user_id, "comments", id])
  def match(conn, "PATCH",  ["users", user_id, "comments", id])
  def match(conn, "DELETE", ["users", user_id, "comments", id])
  def match(conn, "GET",    ["admin", "users"])
  def match(conn, "GET",    ["admin", "users", id, "edit"])
  def match(conn, "GET",    ["admin", "users", id])
  def match(conn, "GET",    ["admin", "users", "new"])
  def match(conn, "POST",   ["admin", "users"])
  def match(conn, "PUT",    ["admin", "users", id])
  def match(conn, "PATCH",  ["admin", "users", id])
  def match(conn, "DELETE", ["admin", "users", id])
end

Generated match definitions

get "/pages/:slug", PageCtrl, :show

# GET /pages/about
#                      ["pages", "about"]
def match(conn, "GET", ["pages", slug]) do
  Controller.perform_action(conn, PageCtrl, :show, slug: slug)
end

get "/files/*path", FileCtrl, :show

# GET /files/Users/chris/Downloads
#                      ["files", "Users", "chris", "Downlaods"]
def match(conn, "GET", ["files" | path]) do
  Controller.perform_action(conn, FileCtrl, :show, path: path)
end

Controllers

defmodule App.PageController do
  use Phoenix.Controller
 
  plug :authenticate
  plug :action
  # plug :render
  
  def authenticate(conn, _) do
    assign conn, :current_user, find_authorized_user!(conn)
  end
  
  def show(conn, %{"slug" => slug}) do
    render conn, "show", page: Repo.get(Page, slug)
  end
end

Views & Templates

Views render templates
Views serve as a presentation layer
Module hierarchy for shared context
Templates are precompiled into views
EEx & Haml engine support

Views

defmodule App.Views do
  defmacro __using__(_options) do
    quote do
      use Phoenix.View, templates_root: unquote(Path.join([__DIR__, 
                                                          "templates"]))
      import unquote(__MODULE__)
      # Expanded within all views for aliases, imports, etc
      alias App.Views
    end
  end

  # Funcs defined here are available to all other views/templates
  def new_line_to_br(txt) do
    String.split(txt, "\n") |> Enum.map_join("<br>", &escape/1) |> safe
  end
end

defmodule App.PagesView do
  use App.Views
  
  def title(%Page{title: title, date: date}), do: "#{title} - #{date}"
end

Templates

<html>
  <body>
    <h1><%= @page_title %></h1>
    <%= @inner %>
  </body>
</html>

<h2>Entries</h2>
<ul>
  <%= for entry <- @entries do %>
    <li>
      <%= new_line_to_br entry.body %>
    </li>
  <% end %>
</ul>

├── templates
│   ├── layout
│   │   └── application.html.eex
│   └── page
│       └── index.html.eex
│       └── show.html.eex
├── views
│   ├── layout_view.ex
│   └── page_view.ex

iex> App.PageView.render("index.html", [])
"<h1>Index</h1>..."

defmodule App.PageView do
  use App.Views

  def render("index.json", attributes \\ []) do
    JSON.encode! %{
      results: attributes[:results]
    }
  end
end

iex> App.PageView.render("index.json", [])
"{\"results\":[\"id\":123...."

Channels

WebSocket / PubSub Abstraction
Handle socket events and broadcast
Handle socket authorization for channel subscription
phoenix.js browser client
Mobile clients

iOS client (alpha)
Android client, asap

Multiplatform

Channels -Router

defmodule Chat.Router do
  use Phoenix.Router
  use Phoenix.Router.Socket, mount: "/ws"

  ...
  get "/", Chat.PageController, :index, as: :page  ...

  channel "rooms", Chat.RoomChannel
end

Channels - Handler

defmodule Chat.RoomChannel do
  use Phoenix.Channel

  def join(socket, "lobby", %{"user" => user}) do
    reply socket, "join", %{status: "connected"}    
    broadcast socket, "user:entered", %{user: user}
    
    {:ok, socket}
  end

  def join(socket, private_topic, message) do
    {:error, socket, :unauthorized}
  end

  def event(socket, "new:msg", %{user: user, body: body}) do
    broadcast socket, "new:msg", %{user: user, body: body}
    socket
  end
end

Channels - Client

var socket = new Phoenix.Socket("ws://" + location.host +  "/ws");

socket.join("rooms", "lobby", {}, function(chan){
  $input.on("enterPressed", function(e) {
    chan.send("new:msg", {
      user: $user.val(),
      body: $input.val()
    });
  });
  chan.on("join", function(message){
    $status.text("joined");
  });
  chan.on("new:msg", function(message){
    $messages.append(messageTemplate(message));
  });
});

PUBSUB - FROM anywhere


iex> Channel.broadcast "rooms", "lobby", "new:msg", %{
...>   user: "iex",
...>   body: "Hello from iex!"
...> }

Channel DEMO

LooKing AHEAD

Phoenix 1.0

Standard Web stack

Routing, Controllers, Views, I18n

Realtime Layer

Channels
Topics
iOS & Android clients

Elixir Logger integration
Resource Protocol
Comprehensive Guides

phoenixframework.org

Looking Ahead

Phoenix 1.0+

Distributed Services
Service/Node discovery

Distributed Services

Inspired by riak_core
Toolkit for easily building fault tolerance services that scale
Decentralized, masterless service registration (eventually)

Phoenix Services

Phoenix Nodes advertise services
Automatically added, removed from local service register on node ups/downs

config :phoenix, :nodes, [:"n1@host", :"n2@host"]

$ mix phoenix.start
Running App.Router with Cowboy on port 4000

$ mix phoenix.start PageCrawler PageIndexer
Registering PageCrawler, PageIndexer on cluster

Phoenix Services - pseudo code

defmodule PageCrawler do
  use Phoenix.Service
  
  def command({:crawl, %{url: url}}, _sender, state) do
    state |> status |> crawl
  end
  defp crawl(:busy, state) do
    reply({:next, :busy}, state)
  end
  defp crawl(_status, state) do
    case Page.fetch(url) do
      {:ok, content}    -> reply({:ok, content}, state)
      {:error, :reason} -> reply({:error, reason}, state)
    end
  end
end


{:ok, page} = Service.call(PageCrawler, {:crawl, %{url: url}})

LET's Build the future

@chris_mccord

chris@chrismccord.com

github.com/phoenixframework/phoenix

irc.freenode.net/elixir-lang