1..1_000_000
|> Enum.map(foo)
|> Enum.map(bar)

def f(a) do
  a |> foo |> bar
end

1..1_000_000
|> Enum.map(foo)
|> Enum.map(bar)

cd ex_blog
mix ecto.create

defmodule ExBlogWeb.Router do
  use ExBlogWeb, :router

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
  end

  pipeline :api do
    plug :accepts, ["json"]
  end

  scope "/", ExBlogWeb do
    pipe_through :browser

    get "/", PageController, :index
    resources "/users", UserController # ここ追加！
  end

  # Other scopes may use custom stacks.
  # scope "/api", ExBlogWeb do
  #   pipe_through :api
  # end
end

defmodule ExBlog.Repo.Migrations.CreateUsers do
  use Ecto.Migration

  def change do
    create table(:users) do
      add :name, :string
      add :email, :string
      add :password, :string

      timestamps()
    end

    create unique_index(:users, [:email])
  end
end

defmodule ExBlog.Repo.Migrations.CreateUsers do
  use Ecto.Migration

  def change do
    create table(:users) do
      add :name, :string, null: false # ここ追加
      add :email, :string, null: false # ここ追加
      add :password, :string, null: false # ここ追加

      timestamps()
    end

    create unique_index(:users, [:email])
  end
end

defmodule ExBlog.Repo.Migrations.CreateArticles do
  use Ecto.Migration

  def change do
    create table(:articles) do
      add :title, :string
      add :content, :string
      add :user_id, references(:users, on_delete: :nothing)

      timestamps()
    end

    create index(:articles, [:user_id])
  end
end

defmodule ExBlog.Repo.Migrations.CreateArticles do
  use Ecto.Migration

   def change do
    create table(:articles) do
      add :title, :string, null: false ## ここ変更
      add :content, :string
      add :user_id, references(:users, on_delete: :delete_all), null: false ## ここ変更

      timestamps()
    end

    create index(:articles, [:user_id])
  end
end

defmodule ExBlog.Accounts.User do
  use Ecto.Schema
  import Ecto.Changeset


  schema "users" do
    field :email, :string
    field :name, :string
    field :password, :string

    timestamps()
  end

  @doc false
  def changeset(user, attrs) do
    user
    |> cast(attrs, [:name, :email, :password])
    |> validate_required([:name, :email, :password])
    |> unique_constraint(:email)
  end
end

defmodule ExBlog.Accounts.User do
  use Ecto.Schema
  import Ecto.Changeset
  alias ExBlog.Blog.Article # ここ追加

  schema "users" do
    field :email, :string
    field :name, :string
    field :password, :string

    has_many :articles, Article # ここ追加
    timestamps()
  end

  @doc false
  def changeset(user, attrs) do
    user
    |> cast(attrs, [:name, :email, :password])
    |> validate_required([:name, :email, :password])
    |> unique_constraint(:email)
  end
end

defmodule ExBlog.Blog.Article do
  use Ecto.Schema
  import Ecto.Changeset


  schema "articles" do
    field :content, :string
    field :title, :string
    field :user_id, :id

    timestamps()
  end

  @doc false
  def changeset(article, attrs) do
    article
    |> cast(attrs, [:title, :content])
    |> validate_required([:title, :content])
  end
end

defmodule ExBlog.Blog.Article do
  use Ecto.Schema
  import Ecto.Changeset
  alias ExBlog.Accounts.User # ここ追加

  schema "articles" do
    field :content, :string
    field :title, :string

    belongs_to :user, User # ここ追加
    timestamps()
  end

  @doc false
  def changeset(article, attrs) do
    article
    |> cast(attrs, [:title, :content])
    |> validate_required([:title, :content])
  end
end

<h1>Listing Users</h1>

<table>
  <thead>
    <tr>
      <th>Name</th>
      <th>Email</th>
-      <th>Password</th>

      <th></th>
    </tr>
  </thead>
  <tbody>
<%= for user <- @users do %>
    <tr>
      <td><%= user.name %></td>
      <td><%= user.email %></td>
-      <td><%= user.password %></td>

      <td>
        <%= link "Show", to: Routes.user_path(@conn, :show, user) %>
        <%= link "Edit", to: Routes.user_path(@conn, :edit, user) %>
        <%= link "Delete", to: Routes.user_path(@conn, :delete, user), method: :delete, data: [confirm: "Are you sure?"] %>
      </td>
    </tr>
<% end %>
  </tbody>
</table>

<span><%= link "New User", to: Routes.user_path(@conn, :new) %></span>

<h1>Show User</h1>

<ul>

  <li>
    <strong>Name:</strong>
    <%= @user.name %>
  </li>

  <li>
    <strong>Email:</strong>
    <%= @user.email %>
  </li>

-  <li>
-    <strong>Password:</strong>
-    <%= @user.password %>
-  </li>

</ul>

<span><%= link "Edit", to: Routes.user_path(@conn, :edit, @user) %></span>
<span><%= link "Back", to: Routes.user_path(@conn, :index) %></span>

<%= form_for @changeset, @action, fn f -> %>
  <%= if @changeset.action do %>
    <div class="alert alert-danger">
      <p>Oops, something went wrong! Please check the errors below.</p>
    </div>
  <% end %>

  <%= label f, :name %>
  <%= text_input f, :name %>
  <%= error_tag f, :name %>

  <%= label f, :email %>
  <%= text_input f, :email %>
  <%= error_tag f, :email %>

  <%= label f, :password %>
-  <%= text_input f, :password %>
+  <%= password_input f, :password %>
  <%= error_tag f, :password %>

  <div>
    <%= submit "Save" %>
  </div>
<% end %>

      {:guardian, "~> 1.1"},
      {:comeonin, "~> 4.1"},
      {:bcrypt_elixir, "~> 1.1"}

# This file is responsible for configuring your application
# and its dependencies with the aid of the Mix.Config module.
#
# This configuration file is loaded before any dependency and
# is restricted to this project.

# General application configuration
use Mix.Config

config :ex_blog,
  ecto_repos: [ExBlog.Repo]

# Configures the endpoint
config :ex_blog, ExBlogWeb.Endpoint,
...

+ config :ex_blog, ExBlog.Accounts.Guardian,
+   issuer: "ex_blog",
+   secret_key: # mix guardian.gen.secret の結果を貼り付け

# Use Jason for JSON parsing in Phoenix
config :phoenix, :json_library, Jason

# Import environment specific config. This must remain at the bottom
# of this file so it overrides the configuration defined above.
import_config "#{Mix.eｚnv()}.exs"

secret_key: "${EX_BLOG_GUARDIAN_KEY}"

defmodule ExBlogWeb.Router do
  use ExBlogWeb, :router

  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_flash
    plug :protect_from_forgery
    plug :put_secure_browser_headers
  end

  pipeline :api do
    plug :accepts, ["json"]
  end

+ pipeline :auth do
+   plug ExBlog.Accounts.Pipeline
+ end
+ pipeline :ensure_auth do
+   plug Guardian.Plug.EnsureAuthenticated
+ end

  scope "/", ExBlogWeb do
-    pipe_through :browser
+    pipe_through [:browser, :auth]

+     get "/", PageController, :index
+     get "/signin", UserController, :new
+     post "/signin", UserController, :create
+     get "/login", SessionController, :new
+     post "/login", SessionController, :create
+     delete "/logout", SessionController, :delete
+   end
-    resources "/users", UserController
+   scope "/", ExBlogWeb do
+     pipe_through [:browser, :auth, :ensure_auth]
+     resources "/users", UserController, except: [:new, :create]
    resources "/articles", ArticleController
  end

  # Other scopes may use custom stacks.
  # scope "/api", ExBlogWeb do
  #   pipe_through :api
  # end
end

defmodule ExBlog.Accounts.Guardian do
  use Guardian, otp_app: :ex_blog
  alias ExBlog.Accounts
  def subject_for_token(user, _claims) do
    {:ok, to_string(user.id)}
  end
  def resource_from_claims(claims) do
    user = claims["sub"]
    |> Accounts.get_user!
    {:ok, user}
    # If something goes wrong here return {:error, reason}
  end
end

defmodule ExBlog.Accounts.Pipeline do
  use Guardian.Plug.Pipeline,
    otp_app: :ex_blog,
    error_handler: ExBlog.Accounts.ErrorHandler,
    module: ExBlog.Accounts.Guardian
  # If there is a session token, validate it
  plug Guardian.Plug.VerifySession, claims: %{"typ" => "access"}
  # If there is an authorization header, validate it
  plug Guardian.Plug.VerifyHeader, claims: %{"typ" => "access"}
  # Load the user if either of the verifications worked
  plug Guardian.Plug.LoadResource, allow_blank: true
end

defmodule ExBlog.Accounts.ErrorHandler do
  import Plug.Conn
  def auth_error(conn, {type, _reason}, _opts) do
    body = to_string(type)
    conn
    |> put_resp_content_type("text/plain")
    |> send_resp(401, body)
  end
end

  alias ExBlog.Accounts.User
+  alias Comeonin.Bcrypt
...

+  def authenticate_user(email, plain_text_password) do
+    query = from u in User, where: u.email == ^email
+    Repo.one(query)
+    |> check_password(plain_text_password)
+  end
+  defp check_password(nil, _), do: {:error, "Incorrect username or password"}
+  defp check_password(user, plain_text_password) do
+    case Bcrypt.checkpw(plain_text_password, user.password) do
+      true -> {:ok, user}
+      false -> {:error, "Incorrect username or password"}
+    end
+  end
+ end   
end

defmodule ExBlog.Accounts.User do
  use Ecto.Schema
  import Ecto.Changeset
  alias ExBlog.Blog.Article
+  alias Comeonin.Bcrypt

  schema "users" do
    field :email, :string
    field :name, :string
    field :password, :string

    has_many :articles, Article # ここ追加
    timestamps()
  end

  @doc false
  def changeset(user, attrs) do
    user
    |> cast(attrs, [:name, :email, :password])
    |> validate_required([:name, :email, :password])
    |> unique_constraint(:email)
+    |> validate_format(:email, ~r/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+    |> validate_length(:password, min: 5)
+    |> put_pass_hash()
  end
+
+  defp put_pass_hash(%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset) do
+    change(changeset, password: Bcrypt.hashpwsalt(password))
+  end
+  defp put_pass_hash(changeset), do: changeset
end

defmodule ExBlogWeb.LayoutView do
  use ExBlogWeb, :view
+  alias ExBlog.Accounts.Guardian
+  def current_user(conn) do
+    Guardian.Plug.current_resource(conn)
+  end
end

  def create(conn, %{"user" => user_params}) do
    case Accounts.create_user(user_params) do
-      {:ok, user} ->
+      {:ok, _user} ->
        conn
        |> put_flash(:info, "User created successfully.")
-        |> redirect(to: Routes.user_path(conn, :show, user))
+        |> redirect(to: Routes.page_path(conn, :index))

      {:error, %Ecto.Changeset{} = changeset} ->
        render(conn, "new.html", changeset: changeset)
    end
  end

defmodule ExBlogWeb.SessionController do
  use ExBlogWeb, :controller
  alias ExBlog.Accounts
  alias ExBlog.Accounts.User
  alias ExBlog.Accounts.Guardian
   def new(conn, _params) do
    changeset = Accounts.change_user(%User{})
    render(conn, "new.html", changeset: changeset)
  end
   def create(conn, %{"user" => %{"email" => email, "password" => password}}) do
    Accounts.authenticate_user(email, password)
    |> login_reply(conn)
  end
   defp login_reply({:error, error}, conn) do
    conn
    |> put_flash(:error, error)
    |> redirect(to: Routes.session_path(conn, :new))
  end
  defp login_reply({:ok, user}, conn) do
    conn
    |> put_flash(:info, "Welcome back!")
    |> Guardian.Plug.sign_in(user)
    |> redirect(to: "/")
  end
   def delete(conn, _) do
    conn
    |> Guardian.Plug.sign_out()
    |> put_flash(:info, "Logout successfully.")
    |> redirect(to: Routes.page_path(conn, :index))
  end
end

defmodule ExBlogWeb.SessionView do
  use ExBlogWeb, :view
end

<h2>Login Page</h2>
<%= form_for @changeset, Routes.session_path(@conn, :create), fn f -> %>
   <div class="form-group">
    <%= label f, :email, class: "control-label" %>
    <%= text_input f, :email, class: "form-control" %>
    <%= error_tag f, :email %>
  </div>
  <div class="form-group">
    <%= label f, :password, class: "control-label" %>
    <%= password_input f, :password, class: "form-control" %>
    <%= error_tag f, :password %>
  </div>
  <div class="form-group">
    <%= submit "Submit", class: "btn btn-primary" %>
  </div>
<% end %>

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
    <title>ExBlog · Phoenix Framework</title>
    <link rel="stylesheet" href="<%= Routes.static_path(@conn, "/css/app.css") %>"/>
  </head>
  <body>
    <header>
      <section class="container">
        <nav role="navigation">
          <ul>
-            <li><a href="https://hexdocs.pm/phoenix/overview.html">Get Started</a></li>
+            <%= if current_user(@conn) do %>
+              <li><%= link "Logout", to: Routes.session_path(@conn, :delete), method: :delete %></li>
+            <% end %>
          </ul>
        </nav>
        <a href="http://phoenixframework.org/" class="phx-logo">
          <img src="<%= Routes.static_path(@conn, "/images/phoenix.png") %>" alt="Phoenix Framework Logo"/>
        </a>
      </section>
    </header>
    <main role="main" class="container">
      <p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
      <p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
      <%= render @view_module, @view_template, assigns %>
    </main>
    <script type="text/javascript" src="<%= Routes.static_path(@conn, "/js/app.js") %>"></script>
  </body>
</html>

defmodule W do
  def judge do
    receive do
      {_,msg} ->
        if safe(msg) do
          :io.write(msg)
        end
    end
  end

  def safe([]) do true end
  def safe([l|ls]) do
    if safe1(ls,l,1) do
      safe(ls)
    else
      false
    end
  end

  def safe1([],_,_) do true end
  def safe1([l|ls],a,n) do
    if a+n == l || a-n == l do
      false
    else
      safe1(ls,a,n+1)
    end
  end
end


defmodule M do
    def queens(n) do
    Enum.to_list(1..n)
    |> perm
  end

  def perm (ls) do
    perm1(ls,[])
  end

  def perm1([],a) do
    ls = Enum.reverse(a)
    pid = spawn(W, :judge, [])
    send pid, {self(),ls}
  end
  def perm1(ls,a) do
    Enum.each(ls,fn(n) ->
                  perm1(ls--[n],[n|a]) end)
  end
end

defmodule M do
  def pqueens(n) do
    pqueens1(n,1)
    pqueens2(n,[])
  end

  def queens(n) do
    ls = Enum.to_list(1..n)
    W.perm_list(ls)
  end

  def pqueens1(n,x) do
    if x>n do
      true
    else
      pid = spawn(W,:part,[])
      send pid, {self(),{n,x}}
      pqueens1(n,x+1)
    end
  end

  def pqueens2(0,ans) do ans end
  def pqueens2(n,ans) do
    receive do
      {:answer, msg } ->
        pqueens2(n-1,msg++ans)
    end
  end
end

defmodule W do

  def part do
    receive do
      {sender,{n,x}} -> send sender,{:answer, W.part_perm_list(n,x) }
    end
  end

  def part_perm_list(n,x) do
    ls = Enum.to_list(1..n) -- [x]
    perm_list1(ls,[x],[])
  end

  def perm_list(ls) do
    perm_list1(ls,[],[])
  end

  def perm_list1([],a,b) do
    if safe(a) && a != [] do
      [Enum.reverse(a)|b]
    else
      b
    end
  end

  def perm_list1(ls,a,b) do
    if safe(a) do
      List.foldr(ls,
                b,
                fn(x,y) -> perm_list1(ls--[x],[x|a],y) end)
    else
      List.foldr(ls,
                b,
                fn(x,y) -> perm_list1([],[],y) end)
    end
  end

  def safe([]) do true end
  def safe([l|ls]) do
    if safe1(ls,l,1) do
      safe(ls)
    else
      false
    end
  end

  def safe1([],_,_) do true end
  def safe1([l|ls],a,n) do
    if a+n == l || a-n == l do
      false
    else
      safe1(ls,a,n+1)
    end
  end
end

#並行処理版
iex(11)> T.time(M.pqueens(9))
"time: 0 micro second"
"-------------"
[
  [3, 1, 4, 7, 9, 2, 5, 8, 6],...]

iex(7)> T.time(M.pqueens(10))
"time: 16000 micro second"
"-------------"
[
  [8, 1, 3, 6, 9, 7, 10, 4, 2, 5],...]

#逐次処理版
iex(9)> T.time(M.queens(9))
"time: 16000 micro second"
"-------------"
[
  [1, 3, 6, 8, 2, 4, 9, 7, 5],...]



iex(8)> T.time(M.queens(10))
"time: 63000 micro second"
"-------------"
[
  [1, 3, 6, 8, 10, 5, 9, 2, 4, 7],...]

cd assets
yarn add vue
yarn add -D vue-loader vue-template-compiler

const path = require('path');
const glob = require('glob');
const MiniCssExtractPlugin = require('mini-css-extract-plugin');
const UglifyJsPlugin = require('uglifyjs-webpack-plugin');
const OptimizeCSSAssetsPlugin = require('optimize-css-assets-webpack-plugin');
const CopyWebpackPlugin = require('copy-webpack-plugin');
const VueLoaderPlugin = require('vue-loader/lib/plugin'); // 追加

module.exports = (env, options) => ({
  optimization: {
    minimizer: [
      new UglifyJsPlugin({ cache: true, parallel: true, sourceMap: false }),
      new OptimizeCSSAssetsPlugin({})
    ]
  },
  entry: './js/app.js',
  output: {
    filename: 'app.js',
    path: path.resolve(__dirname, '../priv/static/js')
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: 'babel-loader'
        }
      },
      // 追加
      {
        test: /\.vue$/,
        use: {
          loader: 'vue-loader'
        }
      },
      {
        test: /\.css$/,
        use: [MiniCssExtractPlugin.loader, 'css-loader']
      }
    ]
  },
  // 追加
  resolve: {
    extensions: ['.js', '.vue', '.json'],
    alias: {
      vue$: 'vue/dist/vue.esm.js',
    }
  },
  plugins: [
    new MiniCssExtractPlugin({ filename: '../css/app.css' }),
    new CopyWebpackPlugin([{ from: 'static/', to: '../' }]), // ← 末尾のカンマをお忘れなく！
    new VueLoaderPlugin() // 追加
  ]
});

// We need to import the CSS so that webpack will load it.
// The MiniCssExtractPlugin is used to separate it out into
// its own CSS file.
import css from "../css/app.css"

// webpack automatically bundles all modules in your
// entry points. Those entry points can be configured
// in "webpack.config.js".
//
// Import dependencies
//
import "phoenix_html"

// Import local files
//
// Local files can be imported directly using relative paths, for example:
// import socket from "./socket"

// 以下を追加
import Vue from 'vue';
import App from './App.vue';

new Vue(App).$mount('#app');

<template>
<div>タイトル: {{ title }}</div>
</template>

<script>
export default {
  name: 'app',
  data () {
    return {
      title: 'This is App.vue!!'
    }
  }
}
</script>

    <main role="main" class="container">
      <div id="app"></div>
    </main>

yarn run watch

mix phx.server

$ git clone https://github.com/takasehideki/fukuokaex11

$ cd home_weather_phx/

window.onload = function () {
  var csvData = csvToArray("dhtdata.csv");
  var today = "2018-12-04 ";
  ...
};

$ MIX_ENV=dev mix phx.server

defmodule HomeWeatherPhx.Mixfile do
  use Mix.Project

  def project do
    [
      app: :home_weather_phx,
      version: "0.0.1",
      elixir: "~> 1.4",
      elixirc_paths: elixirc_paths(Mix.env),
      compilers: [:phoenix, :gettext] ++ Mix.compilers,
      build_embedded: Mix.env() == :prod,
      start_permanent: Mix.env == :prod,
      deps: deps()
    ]
  end

  # Configuration for the OTP application.
  #
  # Type `mix help compile.app` for more information.
  def application do
    [
      mod: {HomeWeatherPhx.Application, []},
      extra_applications: [:logger, :runtime_tools, :timex]
    ]
  end

  # Specifies which paths to compile per environment.
  defp elixirc_paths(:test), do: ["lib", "test/support"]
  defp elixirc_paths(_),     do: ["lib"]

  # Specifies your project dependencies.
  #
  # Type `mix help deps` for examples and options.
  defp deps do
    [
      {:phoenix, "~> 1.3.2"},
      {:phoenix_pubsub, "~> 1.0"},
      {:phoenix_html, "~> 2.10"},
      {:phoenix_live_reload, "~> 1.0", only: :dev},
      {:gettext, "~> 0.11"},
      {:cowboy, "~> 1.0"},
      {:timex, "~> 3.1"},
      {:grovepi, github: "adkron/grovepi", branch: "master"}
    ]
  end
end

# Watch static and templates for browser reloading.
config :home_weather_phx, HomeWeatherPhxWeb.Endpoint,
  live_reload: [
    patterns: [
      ~r{priv/static/.*(js|css|png|jpeg|jpg|gif|svg|csv)$},
      ~r{priv/gettext/.*(po)$},
      ~r{lib/home_weather_phx_web/views/.*(ex)$},
      ~r{lib/home_weather_phx_web/templates/.*(eex)$}
    ]
  ]

      {:grovepi, github: "adkron/grovepi", branch: "master"}

defmodule HomeWeatherPhx do
  @moduledoc false
  use GenServer
  use Timex
  require Logger

  defstruct [:dht]

  alias GrovePi.{RGBLCD, DHT}

  @us_pin 4 # Use port 4 for Ultrasonic

  def start_link(pin) do
    GenServer.start_link(__MODULE__, pin)
  end

  def init(dht_pin) do
    state = %HomeWeatherPhx{dht: dht_pin}

    {:ok, _pid} = GrovePi.Ultrasonic.start_link(@us_pin)

    RGBLCD.initialize()
    RGBLCD.set_text("Ready!")

    # Create CSV file
    File.write "priv/static/dhtdata.csv", ""

    DHT.subscribe(dht_pin, :changed)
    {:ok, state}
  end

  def handle_info({_pin, :changed, %{temp: temp, humidity: humidity}}, state) do
    # Measure distance
    distance = GrovePi.Ultrasonic.read_distance(@us_pin)
    distance = if distance >= 200, do: 0, else: distance

    # Get date
    date = Timex.now("Asia/Tokyo")
      |> Timex.format!( "%Y-%m-%d %H:%M:%S", :strftime )

    temp = format_temp(temp)
    humidity = format_humidity(humidity)
    distance = format_distance(distance)

    # Write data to CSV
    File.write "priv/static/dhtdata.csv", "#{date},#{temp},#{humidity},#{distance}\n", [:append]

    flash_rgb()

    RGBLCD.set_text(temp)
    RGBLCD.set_cursor(1, 0)
    RGBLCD.write_text(humidity)
    Logger.info temp <> " " <> humidity <> "" <> distance

    {:noreply, state}
  end

  def handle_info(_message, state) do
    {:noreply, state}
  end

  defp flash_rgb() do
    RGBLCD.set_rgb(255, 0, 0)
    Process.sleep(1000)
    RGBLCD.set_color_white()
  end

  defp format_temp(temp) do
    "Temp: #{Float.to_string(temp)} C"
  end

  defp format_humidity(humidity) do
    "Humidity: #{Float.to_string(humidity)}%"
  end

  defp format_distance(distance) do
    "distance: #{distance}cm"
  end
end

defmodule HomeWeatherPhx.Application do
  use Application

  # RGB LCD Screen should use the IC2-1 port
  @dht_pin 7 # Use port 7 for the DHT
  @dht_poll_interval 10_000 # poll every 10 second

  # See https://hexdocs.pm/elixir/Application.html
  # for more information on OTP Applications
  def start(_type, _args) do
    import Supervisor.Spec, warn: false

    # Define workers and child supervisors to be supervised
    children = [
      # Start the endpoint when the application starts
      supervisor(HomeWeatherPhxWeb.Endpoint, []),
      # Start your own worker by calling: HomeWeatherPhx.Worker.start_link(arg1, arg2, arg3)
      # worker(HomeWeatherPhx.Worker, [arg1, arg2, arg3]),

      # Start the GrovePi sensor we want
      worker(GrovePi.DHT, [@dht_pin, [poll_interval: @dht_poll_interval]]),

      # Start the main app
      worker(HomeWeatherPhx, [@dht_pin]),
    ]

    # See https://hexdocs.pm/elixir/Supervisor.html
    # for other strategies and supported options
    opts = [strategy: :one_for_one, name: HomeWeatherPhx.Supervisor]
    Supervisor.start_link(children, opts)
  end

  # Tell Phoenix to update the endpoint configuration
  # whenever the application is updated.
  def config_change(changed, _new, removed) do
    HomeWeatherPhxWeb.Endpoint.config_change(changed, removed)
    :ok
  end
end

  chaos :default do
    delay(
      source_ip: {192, 168, 20, 0},
      source_netmask: {255, 255, 255, 0},
      protocol: :tcp,
      milisec: 100,
      rate: 0
    )
    loss(
      source_ip: {192, 168, 20, 0},
      source_netmask: {255, 255, 255, 0},
      protocol: :tcp,
      rate: 0
    )
    duplicate(
      source_ip: {192, 168, 20, 0},
      source_netmask: {255, 255, 255, 0},
      protocol: :tcp,
      rate: 0
    )
    tcp_ack(
      source_ip: {192, 168, 20, 0},
      source_netmask: {255, 255, 255, 0},
      protocol: :tcp,
      rate: 0
    )
  end

defmacro chaos(identifier \\ :global, attrs \\ [], do: context) do
  do_chaos(identifier, attrs, context)
end

defp do_chaos(identifier, attrs, context) do
  quote do
    Module.register_attribute(__MODULE__, :change_chaos, accumulate: true)
    Module.register_attribute(__MODULE__, :change_chaos_record, accumulate: true)
    Module.register_attribute(__MODULE__, :chaos_pipeline, accumulate: true)

    identifier = unquote(identifier)
    attrs = unquote(attrs)

    Module.put_attribute(__MODULE__, :change_chaos, {:identifier, identifier})

    try do
      unquote(context)
    after
      :ok
    end

    loaded = Eshe.Chaos.__load__(__MODULE__, @change_chaos_record)
    Module.put_attribute(__MODULE__, :chaos_pipeline, loaded)

    def chaos_pipeline, do: @chaos_pipeline
  end
end

    try do
      unquote(context)
    after
      :ok
    end

  defmacro delay(c) do
    quote do
      c = unquote(c)
      Eshe.Chaos.__delay__(__MODULE__, Map.new(c))
    end
  end

  def __delay__(module, c) do
    record = Map.merge(@default_delay_record, c)
    Module.put_attribute(module, :change_chaos_record, {:delay, record})
  end

Module.put_attribute(module, :change_chaos_record, {:delay, record})

def chaos_pipeline([], data, option) do
  {:ok, data, option}
end

def chaos_pipeline([head | tail], data, option) do
  case chaos_type_pipeline(head, data, option) do
    {:ok, data, option} ->
      chaos_pipeline(tail, data, option)

    error ->
      error
  end
end

def chaos_type_pipeline({:delay, record}, data, option) do
  if Eshe.Firewall.match(record, data) do
    rate = record[:rate]
    ran = trunc(:rand.uniform() * 100)

    if rate >= ran do
      time = record[:milisec]
      :timer.sleep(time)
    end

    {:ok, data, option}
  else
    {:ok, data, option}
  end
end

def chaos_type_pipeline({:loss, record}, data, option) do
  if Eshe.Firewall.match(record, data) do
    rate = record[:rate]
    ran = trunc(:rand.uniform() * 100)
    if rate >= ran do
      {:error, {{:message, :chaos_type_loss}, {:record, record}, {:data, data}}}
    else
      {:ok, data, option}
    end
  else
    {:ok, data, option}
  end
end

def chaos_type_pipeline({:duplicate, record}, data, option) do
  if Eshe.Firewall.match(record, data) do
    rate = record[:rate]
    ran = trunc(:rand.uniform() * 100)
    if rate >= ran do
      {:ok, data, Map.merge(%{duplicate: true}, option)}
    else
      {:ok, data, option}
    end
  else
    {:ok, data, option}
  end
end

def chaos_type_pipeline({:tcp_ack, record}, data, option) do
  if Eshe.Firewall.match(record, data) do
    rate = record[:rate]
    ran = trunc(:rand.uniform() * 100)
    if rate >= ran and has_tcp_ack(data) == true do
      {:error, {{:message, :chaos_type_tcp_ack}, {:record, record}, {:data, data}}}
    else
      {:ok, data, option}
    end
  else
    {:ok, data, option}
  end
end

def has_tcp_ack(<<_ :: size(72), 6, _ :: size(80), tcp :: size(106), _:: size(1), 1 :: size(1), _ :: binary>>) do
  false
end
def has_tcp_ack(_) do
  true
end

curl http://localhost:4000/api/v1/users \
  -H "accept: application/json" \
  -H "Authorization:Bearer TOKEN"

describe "GET /api/v1/users" do
  context "is successful" do
    let :token do, "TOKEN"
    let :conn do
      build_conn()
      |> put_req_header("authorization", "Bearer #{token()}")
    end

    it do
      response = get(conn(), "/api/v1/users")
      expect(response.status)
      |> to(eq 200)
    end
  end
end

$ sudo adduser mocamocaland

Adding user `mocamocaland' ...
Adding new group `mocamocaland' (1003) ...
Adding new user `mocamocaland' (1002) with group `mocamocaland' ...
Creating home directory `/home/mocamocaland' ...
Copying files from `/etc/skel' ...
Enter new UNIX password: mocamocaland # 今回はお試しで作っているため
Retype new UNIX password: mocamocaland
passwd: password updated successfully
Changing the user information for mocamocaland
Enter the new value, or press ENTER for the default
# 以下5項目は何も入れずにenterを入力
        Full Name []: 
        Room Number []: 
        Work Phone []: 
        Home Phone []: 
        Other []: 
Is the information correct? [Y/n] # Yを入力してenterを入力

$ gpasswd -a mocamocaland sudo

$ sudo login mocamocaland

$ wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb
$ sudo dpkg -i erlang-solutions_1.0_all.deb
$ sudo apt-get update
$ sudo apt-get -y install esl-erlang
$ sudo apt-get -y install elixir

$ elixir --version
Erlang/OTP 21 [erts-10.1.3] [source] [64-bit] [smp:1:1] [ds:1:1:10] [async-threads:1] [hipe]
Elixir 1.7.4 (compiled with Erlang/OTP 20)

$ sudo apt install nodejs npm

$ sudo apt-get -y install postgresql
$ sudo -u postgres createuser -d phoenix -P

$ sudo -u postgres createdb --owner phoenix nano_planner_prod

$ sudo apt-get -y install nginx

$ cd ~/etc/nginx/sites-available

upstream phoenix {
  server 127.0.0.1:4000;
}

server {
  listen 80;
  server_name `GCPの外部IP`;

  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  proxy_set_header Host $http_host;
  proxy_set_header X-Cluster-Client-Ip $remote_addr;

  location / {
    proxy_pass  http://phoenix;
    allow all;
  }
}

$ cd /etc/nginx/sites-enabled
$ sudo ln -s ../sites-available/nano_planner .
$ sudo systemctl reload nginx

$ sudo login
sampler login: phoenix
Password: phoenix

$ git clone -b master4-deploy https://github.com/oiax/nano_planner.git
$ cd nano_planner
$ cp config/skel/prod.secret.exs config/
$ cd assets
$ npm install
$ npm run deploy
$ cd ..

$ mix deps.get --only prod
$ MIX_ENV=prod mix compile
$ MIX_ENV=prod mix phx.digest
$ MIX_ENV=prod mix release

# エラー内容
$ MIX_ENV=prod mix phx.digest
The input path "priv/static" does not exist

$ mkdir -p ~/app/releases/0.1.0
$ cd _build/prod/rel/nano_planner/releases/0.1.0
$ cp nano_planner.tar.gz ~/app/releases/0.1.0
$ cd ~/app/releases/0.1.0
$ tar -xf nano_planner.tar.gz -C ~/app

$ cd ~/nano_planner
$ MIX_ENV=prod mix ecto.drop # 中身を一旦削除します。
$ MIX_ENV=prod mix ecto.create
$ MIX_ENV=prod mix ecto.migrate
$ MIX_ENV=prod mix run priv/repo/seeds.exs

$ cd ~/app
$ bin/nano_planner start

$ lsof -i:4000

COMMAND   PID    USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
beam.smp 2080 phoenix   15u  IPv6  25000      0t0  TCP *:4000 (LISTEN)

Rustler_export_nifs! {
  "Elixir.LinearRegressorNif", // Elixirのモジュール名を指定
  [
    //("Elixir's func-name, number of arguments, Rust's func)
    ("_fit", 5, nif_fit), 
  ],
  None
}

fn nif_fit<'a>(env: Env<'a>, args: &[Term<'a>])-> NifResult<Term<'a>> {
  let pid = env.pid();
  let mut my_env = OwnedEnv::new();

  let saved_list = my_env.run(|env| -> NifResult<SavedTerm> {
    let _x = args[0].in_env(env);
    let _y = args[1].in_env(env);
    let theta = args[2].in_env(env);
    let alpha = args[3].in_env(env);
    let iterations = args[4].in_env(env);
    Ok(my_env.save(make_tuple(env, &[_x, _y, theta, alpha, iterations])))
  })?;

  std::thread::spawn(move ||  {
    my_env.send_and_clear(&pid, |env| {
      let result: NifResult<Term> = (|| {
        let tuple = saved_list
        .load(env).decode::<(
          Term, 
          Term,
          Term,
          Num,
          i64)>()?; 

        let x: Vec<Vec<Num>> = try!(tuple.0.decode());
        let y: Vec<Vec<Num>> = try!(tuple.1.decode());
        let theta: Vec<Vec<Num>> = try!(tuple.2.decode());
        let alpha: Num = tuple.3;
        let iterations: i64 = tuple.4;

        let tx = transpose(&x);
        let m = y.len() as Num;
        let (row, col) = (theta.len(), theta[0].len());
        let tmp = alpha/m;
        let a :Vec<Vec<Num>> = vec![vec![tmp; col]; row]; 

        let ans = (0..iterations)
          .fold( theta, |theta, _iteration|{
           sub2d(&theta, &emult2d(&mult( &tx, &sub2d( &mult( &x, &theta ), &y ) ), &a))
          });

        Ok(ans.encode(env))
      })();
      match result {
          Err(_err) => env.error_tuple("test failed".encode(env)),
          Ok(term) => term
      }  
    });
  });
  Ok(atoms::ok().to_term(env))
}

# Rust側の関数と対応づけ
def _fit(_x, _y, _theta, _alpha, _iteration), do: exit(:nif_not_loaded)

def to_float(num) when is_integer(num), do: num /1
def to_float(r) when is_list(r) do
    r
    |>Enum.map( &to_float(&1) )
end

def fit( x, y, theta, alpha, iterations ) do
   _fit(
      x |> to_float, 
      y |> to_float, 
      theta |> to_float, 
      alpha |> to_float,
      iterations)
    receive do
      l -> l
    end
  end

let ans = (0..iterations)
  .fold( theta, |theta, _iteration|{
    sub2d(&theta, &emult2d(&mult( &tx, &sub2d( &mult( &x, &theta ), &y ) ), &a))
  });

pub fn sub2d(x: &Vec<Vec<Num>>, y: &Vec<Vec<Num>>) -> Vec<Vec<Num>>{
  x.iter().zip(y.iter())
  .map(|t| sub(&t.0.to_vec(), &t.1.to_vec()))
  .collect()
}

pub fn sub2d(x: &Vec<Vec<Num>>, y: &Vec<Vec<Num>>) -> Vec<Vec<Num>>{
  x.par_iter().zip(y.par_iter())
  .map(|t| sub(&t.0.to_vec(), &t.1.to_vec()))
  .collect()
}

def deps do
  [{:grpc, github: "tony612/grpc-elixir"}]
end

mix deps.get

mix escript.install hex protobuf --force

PATH=~/.mix/escripts:$PATH

protoc --elixir_out=plugins=grpc:./lib/ helloworld.proto

defmodule Helloworld.HelloRequest do
  use Protobuf, syntax: :proto3

  @type t :: %__MODULE__{
    name: String.t
  }
  defstruct [:name]

  field :name, 1, type: :string
end

defmodule Helloworld.HelloReply do
  use Protobuf, syntax: :proto3

  @type t :: %__MODULE__{
    message: String.t
  }
  defstruct [:message]

  field :message, 1, type: :string
end

defmodule Helloworld.Greeter.Service do
  @moduledoc false
  use GRPC.Service, name: "helloworld.Greeter"

  rpc :SayHello, Helloworld.HelloRequest, Helloworld.HelloReply
end

defmodule Helloworld.Greeter.Stub do
  @moduledoc false
  use GRPC.Stub, service: Helloworld.Greeter.Service
end

iex> GRPC.Server.start(Helloworld.Greeter.Server, 50051)
iex> {:ok, channel} = GRPC.Stub.connect("localhost:50051")
iex> request = Helloworld.HelloRequest.new(name: "grpc-elixir")
iex> {:ok, reply} = channel |> Helloworld.Greeter.Stub.say_hello(request)

defmodule Helloworld.Greeter.Server do
  use GRPC.Server, service: Helloworld.Greeter.Service

  @spec say_hello(Helloworld.HelloRequest.t(), GRPC.Server.Stream.t()) ::
          Helloworld.HelloReply.t()
  def say_hello(request, _stream) do
    Helloworld.HelloReply.new(message: "Hello #{request.name}")
  end
end

defmodule YourApp do
  use Application
  def start(_type, _args) do
    import Supervisor.Spec
    children = [
      # ...
      supervisor(GRPC.Server.Supervisor, 
    [{Helloworld.Greeter.Server, 50051}])
    ]

    opts = [strategy: :one_for_one, name: YourApp]
    Supervisor.start_link(children, opts)
  end
end

  def application do
    [
      mod: {YourApp, []}, # これを登録
      extra_applications: [:logger]
    ]
  end

mix grpc.server

$ touch docker-compose.yml
$ touch Dockerfile-go
$ touch Dockerfile-elixir

FROM elixir:1.7.4-alpine

RUN apk -U update && apk --update --no-cache add protobuf git vim && \
    cd ~ && \
    git clone https://github.com/tony612/grpc-elixir.git && \
    mix local.hex --force && \
    mix local.rebar --force && \
    mix hex.info && \
    mix escript.install hex protobuf --force

ENV PATH /root/.mix/escripts:$PATH

CMD ["ash"]

FROM grpc/go:latest

RUN go get -u golang.org/x/net/http2 golang.org/x/net/context && \
    cd /go/src/google.golang.org/grpc/examples/helloworld/greeter_server && \
    go build main.go && \
    cd /go/src/google.golang.org/grpc/examples/helloworld/greeter_client && \
    go build main.go && \
    cd /go/src/google.golang.org/grpc/examples/route_guide/server && \
    go build server.go && \
    cd /go/src/google.golang.org/grpc/examples/route_guide/client && \
    go build client.go

CMD ["/go/src/google.golang.org/grpc/examples/helloworld/greeter_server/main"]

EXPOSE 50051 10000

version: '3'
services:
  elixir-node:
    build:
      context: .
      dockerfile: Dockerfile-elixir
    command: ash
    tty: true
    environment:
      - MIX_ENV=dev

  go-node:
    build:
      context: .
      dockerfile: Dockerfile-go
    # command: sh -c "cd /go/src/google.golang.org/grpc/examples/route_guide/ && server/server"

docker-compose up -d

$ docker-compose exec elixir-node ash

# cd ~/grpc-elixir/examples/helloworld
# mix deps.get && mix compile

# iex -S mix

iex(1)> {:ok, channel} = GRPC.Stub.connect("go-node:50051")
{:ok,
 %GRPC.Channel{
   adapter: GRPC.Adapter.Gun,
   adapter_payload: %{conn_pid: #PID<0.216.0>},
   cred: nil,
   host: "go-node",
   port: 50051,
   scheme: "http"
 }}

iex(2)> {:ok, reply} = channel |> Helloworld.Greeter.Stub.say_hello(Helloworld.HelloRequest.new(name: "grpc-elixir"))
{:ok, %Helloworld.HelloReply{message: "Hello grpc-elixir"}}

iex(3)> {:ok, channel2} = GRPC.Stub.connect("localhost:50051")
** (MatchError) no match of right hand side value: {:error, "Error when opening connection: :timeout"}

# mix grpc.server

$ docker-compose exec go-node bash

cd /go/src/google.golang.org/grpc/examples/helloworld/greeter_client

# sed -i -e s/localhost/elixir-node/ main.go
# go build main.go

# ./main
2018/12/10 05:11:17 Greeting: Hello world

# exit
$ docker-compose down

> elixir --version
Erlang/OTP 20 [erts-9.2.1] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Elixir 1.6.1 (compiled with OTP 20)

> mix phx.new stub_sample --no-ecto --no-brunch
> cd stub_sample

def application do
    [
      mod: {StubSample.Application, []},
      extra_applications: [:logger, :runtime_tools, :httpoison] # <- :httpoison追加
    ]
end

defp deps do
    [
      {:phoenix, "~> 1.3.2"},
      {:phoenix_pubsub, "~> 1.0"},
      {:phoenix_html, "~> 2.10"},
      {:phoenix_live_reload, "~> 1.0", only: :dev},
      {:gettext, "~> 0.11"},
      {:cowboy, "~> 1.0"},
      {:poison, "~> 3.0"}, # <- 追加
      {:httpoison, "~> 1.4"}, # <- 追加
    ]
  end

> mix deps.get

defmodule StubSample.ApiAdapter.Qiita do

  def list_items(url) do
    resp = HTTPoison.get! url
    {:ok, contents} = Poison.decode(resp.body)
    Enum.map(contents, fn(content) -> content["title"] end)
  end

end

iex(1)> StubSample.ApiAdapter.Qiita.list_items("https://qiita.com/api/v2/items?page=1&per_page=10&query=Fukuoka.ex")
["【超残念】fukuoka.ex Elixir／Phoenix Advent Calendar 2018参加を断念",
 "[Elixir]Calendarモジュールを使って、DataFormatを作る方法を色々と試す。",
 "grpc-elixirでGoと通信してみる #1",
 "Elixirでニューラルネットワークを実装しようとした話",
 "Elixir(エリクサー)で数値計算すると幸せになれる",
 "プログラマでも「Figma」ならレイアウトやロゴが簡単にデザインできる",
 "\"show weather\" コマンド作ってみた",
 "データサイエンスプラットフォームEsunaの前処理UI／Elixirコードは、入力データ解析の後、データ内容から自動生成されている",
 "RustElixirで線形回帰を高速化した話",
 "【doctestつき】AtCoder に登録したら解くべき精選過去問 10 問を\"Elixir\"で解いてみた"]

defmodule StubSample.ApiAdapter do

  @callback list_items(url :: String) :: List

end

defmodule StubSample.ApiAdapter.Qiita do

  @behaviour StubSample.ApiAdapter # <- 追記

  def list_items(url) do
    resp = HTTPoison.get! url
    {:ok, contents} = Poison.decode(resp.body)
    Enum.map(contents, fn(content) -> content["title"] end)
  end

end