mix deps            # 显示所有依赖包极其状态
mix deps.get        # 下载未安装的依赖包
mix deps.compile    # 编译依赖包
mix deps.update     # 更新依赖包
mix deps.clean      # 删除所有依赖文件
mix deps.unlock     # 解锁依赖

iex> table = :ets.new(:buckets_registry, [:set, :protected])
8207
iex> :ets.insert(table, {"foo", self})
true
iex> :ets.lookup(table, "foo")
[{"foo", #PID<0.41.0>}]

iex> :ets.new(:buckets_registry, [:named_table])
:buckets_registry
iex> :ets.insert(:buckets_registry, {"foo", self})
true
iex> :ets.lookup(:buckets_registry, "foo")
[{"foo", #PID<0.41.0>}]

defmodule KV.Registry do
  use GenServer
  ## 客户端 API
  @doc """
  启动注册表.
  """
  def start_link(table, event_manager, buckets, opts \\ []) do
    # 1. 现在我们期望该表作为参数传递给服务器
    GenServer.start_link(__MODULE__, {table, event_manager, buckets}, opts)
  end
  @doc """
  查询存储在`table`中的`name`的bucket pid.
  Returns `{:ok, pid}` if a bucket exists, `:error` otherwise.
  """
  def lookup(table, name) do
    # 2. lookup now expects a table and looks directly into ETS.
    #    No request is sent to the server.
    case :ets.lookup(table, name) do
      [{^name, bucket}] -> {:ok, bucket}
      [] -> :error
    end
  end
  @doc """
  确保在`server`中有一个与给定的`name`相关的bucket.
  """
  def create(server, name) do
    GenServer.cast(server, {:create, name})
  end
  ## 服务器回调
  def init({table, events, buckets}) do
    # 3. We have replaced the names HashDict by the ETS table
    ets  = :ets.new(table, [:named_table, read_concurrency: true])
    refs = HashDict.new
    {:ok, %{names: ets, refs: refs, events: events, buckets: buckets}}
  end
  # 4. The previous handle_call callback for lookup was removed
  def handle_cast({:create, name}, state) do
    # 5. Read and write to the ETS table instead of the HashDict
    case lookup(state.names, name) do
      {:ok, _pid} ->
        {:noreply, state}
      :error ->
        {:ok, pid} = KV.Bucket.Supervisor.start_bucket(state.buckets)
        ref = Process.monitor(pid)
        refs = HashDict.put(state.refs, ref, name)
        :ets.insert(state.names, {name, pid})
        GenEvent.sync_notify(state.events, {:create, name, pid})
        {:noreply, %{state | refs: refs}}
    end
  end
  def handle_info({:DOWN, ref, :process, pid, _reason}, state) do
    # 6. Delete from the ETS table instead of the HashDict
    {name, refs} = HashDict.pop(state.refs, ref)
    :ets.delete(state.names, name)
    GenEvent.sync_notify(state.events, {:exit, name, pid})
    {:noreply, %{state | refs: refs}}
  end
  def handle_info(_msg, state) do
    {:noreply, state}
  end
end

# 获取用户名
input_username = IO.gets("Please input your username: ")
username = String.strip(input)
first = String.first(username)
# 获取年龄
input_age = IO.gets("Please input your age:")
age_str = String.strip(input_age)
age = String.to_integer(age_str)

# 单行注释以一个#号开始.
# 没有多行注释,但可以注释多行.
# 要使用elixir shell使用`iex`命令.
# 编译模块使用`elixirc`命令.
# 如果elixir正确安装,应该都在PATH中.

# 这些是数字
3    # 整数
0x1F # 整数
3.0  # 浮点数
# Atoms, that are literals, a constant with name. They start with `:`.
# 原子,是字面的,一个命名常量. 以`:`开始.
:hello # atom
# 元组在内存中是连续地存储的
{1,2,3} # tuple
# 可以使用`elem`函数访问一个元组中的元素
elem({1, 2, 3}, 0) #=> 1
# Lists that are implemented as linked lists.
[1,2,3] # list
# We can access the head and tail of a list as follows:
[head | tail] = [1,2,3]
head #=> 1
tail #=> [2,3]
# In elixir, just like in Erlang, the `=` denotes pattern matching and
# not an assignment.
#
# This means that the left-hand side (pattern) is matched against a
# right-hand side.
#
# This is how the above example of accessing the head and tail of a list works.
# A pattern match will error when the sides don't match, in this example
# the tuples have different sizes.
# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
# There are also binaries
<<1,2,3>> # binary
# Strings and char lists
"hello" # string
'hello' # char list
# Multi-line strings
"""
I'm a multi-line
string.
"""
#=> "I'm a multi-line\nstring.\n"
# Strings are all encoded in UTF-8:
"héllò" #=> "héllò"
# Strings are really just binaries, and char lists are just lists.
<<?a, ?b, ?c>> #=> "abc"
[?a, ?b, ?c]   #=> 'abc'
# `?a` in elixir returns the ASCII integer for the letter `a`
?a #=> 97
# To concatenate lists use `++`, for binaries use `<>`
[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
'hello ' ++ 'world'  #=> 'hello world'
<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
"hello " <> "world"  #=> "hello world"

# Some math
1 + 1  #=> 2
10 - 5 #=> 5
5 * 2  #=> 10
10 / 2 #=> 5.0
# In elixir the operator `/` always returns a float.
# To do integer division use `div`
div(10, 2) #=> 5
# To get the division remainder use `rem`
rem(10, 3) #=> 1
# There are also boolean operators: `or`, `and` and `not`.
# These operators expect a boolean as their first argument.
true and true #=> true
false or true #=> true
# 1 and true    #=> ** (ArgumentError) argument error
# Elixir also provides `||`, `&&` and `!` which accept arguments of any type.
# All values except `false` and `nil` will evaluate to true.
1 || true  #=> 1
false && 1 #=> false
nil && 20  #=> nil
!true #=> false
# For comparisons we have: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>`
1 == 1 #=> true
1 != 1 #=> false
1 < 2  #=> true
# `===` and `!==` are more strict when comparing integers and floats:
1 == 1.0  #=> true
1 === 1.0 #=> false
# We can also compare two different data types:
1 < :hello #=> true
# The overall sorting order is defined below:
# number < atom < reference < functions < port < pid < tuple < list < bit string
# To quote Joe Armstrong on this: "The actual order is not important,
# but that a total ordering is well defined is important."

# `if` expression
if false do
  "This will never be seen"
else
  "This will"
end
# There's also `unless`
unless true do
  "This will never be seen"
else
  "This will"
end
# Remember pattern matching? Many control-flow structures in elixir rely on it.
# `case` allows us to compare a value against many patterns:
case {:one, :two} do
  {:four, :five} ->
    "This won't match"
  {:one, x} ->
    "This will match and bind `x` to `:two`"
  _ ->
    "This will match any value"
end
# It's common to bind the value to `_` if we don't need it.
# For example, if only the head of a list matters to us:
[head | _] = [1,2,3]
head #=> 1
# For better readability we can do the following:
[head | _tail] = [:a, :b, :c]
head #=> :a
# `cond` lets us check for many conditions at the same time.
# Use `cond` instead of nesting many `if` expressions.
cond do
  1 + 1 == 3 ->
    "I will never be seen"
  2 * 5 == 12 ->
    "Me neither"
  1 + 2 == 3 ->
    "But I will"
end
# It is common to see the last condition equal to `true`, which will always match.
cond do
  1 + 1 == 3 ->
    "I will never be seen"
  2 * 5 == 12 ->
    "Me neither"
  true ->
    "But I will (this is essentially an else)"
end
# `try/catch` is used to catch values that are thrown, it also supports an
# `after` clause that is invoked whether or not a value is caught.
try do
  throw(:hello)
catch
  message -> "Got #{message}."
after
  IO.puts("I'm the after clause.")
end
#=> I'm the after clause
# "Got :hello"

# Anonymous functions (notice the dot)
square = fn(x) -> x * x end
square.(5) #=> 25
# They also accept many clauses and guards.
# Guards let you fine tune pattern matching,
# they are indicated by the `when` keyword:
f = fn
  x, y when x > 0 -> x + y
  x, y -> x * y
end
f.(1, 3)  #=> 4
f.(-1, 3) #=> -3
# Elixir also provides many built-in functions.
# These are available in the current scope.
is_number(10)    #=> true
is_list("hello") #=> false
elem({1,2,3}, 0) #=> 1
# You can group several functions into a module. Inside a module use `def`
# to define your functions.
defmodule Math do
  def sum(a, b) do
    a + b
  end
  def square(x) do
    x * x
  end
end
Math.sum(1, 2)  #=> 3
Math.square(3) #=> 9
# To compile our simple Math module save it as `math.ex` and use `elixirc`
# in your terminal: elixirc math.ex
# Inside a module we can define functions with `def` and private functions with `defp`.
# A function defined with `def` is available to be invoked from other modules,
# a private function can only be invoked locally.
defmodule PrivateMath do
  def sum(a, b) do
    do_sum(a, b)
  end
  defp do_sum(a, b) do
    a + b
  end
end
PrivateMath.sum(1, 2)    #=> 3
# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
# Function declarations also support guards and multiple clauses:
defmodule Geometry do
  def area({:rectangle, w, h}) do
    w * h
  end
  def area({:circle, r}) when is_number(r) do
    3.14 * r * r
  end
end
Geometry.area({:rectangle, 2, 3}) #=> 6
Geometry.area({:circle, 3})       #=> 28.25999999999999801048
# Geometry.area({:circle, "not_a_number"})
#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
# Due to immutability, recursion is a big part of elixir
defmodule Recursion do
  def sum_list([head | tail], acc) do
    sum_list(tail, acc + head)
  end
  def sum_list([], acc) do
    acc
  end
end
Recursion.sum_list([1,2,3], 0) #=> 6
# Elixir modules support attributes, there are built-in attributes and you
# may also add custom ones.
defmodule MyMod do
  @moduledoc """
  This is a built-in attribute on a example module.
  """
  @my_data 100 # This is a custom attribute.
  IO.inspect(@my_data) #=> 100
end

# Structs are extensions on top of maps that bring default values,
# compile-time guarantees and polymorphism into Elixir.
defmodule Person do
  defstruct name: nil, age: 0, height: 0
end
joe_info = %Person{ name: "Joe", age: 30, height: 180 }
#=> %Person{age: 30, height: 180, name: "Joe"}
# Access the value of name
joe_info.name #=> "Joe"
# Update the value of age
older_joe_info = %{ joe_info | age: 31 }
#=> %Person{age: 31, height: 180, name: "Joe"}
# The `try` block with the `rescue` keyword is used to handle exceptions
try do
  raise "some error"
rescue
  RuntimeError -> "rescued a runtime error"
  _error -> "this will rescue any error"
end
# All exceptions have a message
try do
  raise "some error"
rescue
  x in [RuntimeError] ->
    x.message
end

# Elixir relies on the actor model for concurrency. All we need to write
# concurrent programs in elixir are three primitives: spawning processes,
# sending messages and receiving messages.
# To start a new process we use the `spawn` function, which takes a function
# as argument.
f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
spawn(f) #=> #PID<0.40.0>
# `spawn` returns a pid (process identifier), you can use this pid to send
# messages to the process. To do message passing we use the `send` operator.
# For all of this to be useful we need to be able to receive messages. This is
# achieved with the `receive` mechanism:
defmodule Geometry do
  def area_loop do
    receive do
      {:rectangle, w, h} ->
        IO.puts("Area = #{w * h}")
        area_loop()
      {:circle, r} ->
        IO.puts("Area = #{3.14 * r * r}")
        area_loop()
    end
  end
end
# Compile the module and create a process that evaluates `area_loop` in the shell
pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
# Send a message to `pid` that will match a pattern in the receive statement
send pid, {:rectangle, 2, 3}
#=> Area = 6
#   {:rectangle,2,3}
send pid, {:circle, 2}
#=> Area = 12.56000000000000049738
#   {:circle,2}
# The shell is also a process, you can use `self` to get the current pid
self() #=> #PID<0.27.0>

%% 创建一个预处理语句
emysql:prepare(stmt_isbound, <<"SELECT COUNT(sn) FROM online_users WHERE sn = ? AND jid = ?">>),
%% 执行预处理语句
{_, _, _, [[Rows]], _} = emysql:execute(pool_gbox_messager, stmt_isbound, [Sn, Jid]),
?INFO_MSG("COUNT: ~p~n", [Rows])

-export([
    %% Update all the modified modules
    update/0,
    %% Update only the specified modules
    update/1,
    %% Get information about the modified modules
    update_info/0
]).

ejabberdctl stop

ejabberdctl live

make && make install

root@bffd81e6215e:~/ejabberd# ejabberdctl update_list
mod_gbox_messager

(ejabberd@localhost)2> ejabberd_update:update().
07:57:08.491 [debug] beam files: [mod_gbox_messager]
07:57:08.492 [debug] script: [{load_module,mod_gbox_messager}]
07:57:08.492 [debug] low level script: [
    {
        load_object_code,
        {
            ejabberd,[],[mod_gbox_messager]
        }
    },
    point_of_no_return,{
        load,{
            mod_gbox_messager,
            brutal_purge,brutal_purge
        }
    }
]
07:57:08.492 [debug] check: {ok,[]}
07:57:08.497 [debug] eval: {ok,[]}

(ejabberd@localhost)4> ejabberd_update:update_info().
08:25:24.357 [debug] beam files: [mod_gbox_messager]
08:25:24.358 [debug] script: [{load_module,mod_gbox_messager}]
08:25:24.358 [debug] low level script: [
    {
        load_object_code,
        {ejabberd,[],[mod_gbox_messager]}
    },
    point_of_no_return,
    {load,{mod_gbox_messager,brutal_purge,brutal_purge}}
]
08:25:24.358 [debug] check: {ok,[]}
{
    ok,
    "/lib/ejabberd/ebin",
    [mod_gbox_messager],
    [{load_module,mod_gbox_messager}],
    [
        {load_object_code,{ejabberd,[],[mod_gbox_messager]}},
        point_of_no_return,
        {load,{mod_gbox_messager,brutal_purge,brutal_purge}}
    ],
    ok
}

%% 打印需要更新的模块
print_modules() ->
    {ok,_Ebin,Modules,_,_,_} = ejabberd_update:update_info,
    ?INFO_MSG("modules to update: ~p~n", [Modules]).

GET http://localhost/update-modules/all
POST http://localhost/update-modules

1> lists:keysearch(mail,1, [{username, "13012345678"}, {mail, "13012345678@139.com"}, {tel, 13012345678}]).
{value,{mail,"13012345678@139.com"}}

3> lists:keyfind(mail,1, [{username, "13012345678"}, {mail, "13012345678@139.com"}, {tel, 13012345678}]).
{mail,"13012345678@139.com"}

# Elixir module
defmodule Test do
    @doc """
    一个Echo方法用于输出Hello World.
    """
    def echo do
        IO.puts "Hello World!"
    end
end

root# iex

iex(1)> c("hello.exs")

root@fd4cc081e295:~/elixir/docs# mix deps.get
* Updating ex_doc (git://github.com/elixir-lang/ex_doc.git)
==> ex_doc
Could not find hex, which is needed to build dependency :earmark
Shall I install hex? [Yn] Y
2014-10-13 09:07:56 URL:https://s3.amazonaws.com/s3.hex.pm/installs/hex.ez [240877/240877] -> "/root/.mix/archives/hex.ez" [1]
* creating /root/.mix/archives/hex.ez

mix docs

export PATH=/root/elixir-1.0.1/bin:$PATH

root@fd4cc081e295:~/elixir-1.0.1/bin# iex
Erlang/OTP 17 [erts-6.2] [source] [64-bit] [async-threads:10] [kernel-poll:false]
Interactive Elixir (1.0.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>

IO.puts "Hello World!

root@fd4cc081e295:~/elixir# elixir hello.exs
Hello World!

get_title(Lang, <<"announce">>) ->
    translate:translate(Lang, <<"Announcements">>);
get_title(Lang, ?NS_ADMIN_ANNOUNCE_ALL) ->
    translate:translate(Lang, <<"Send announcement to all users">>);
get_title(Lang, ?NS_ADMIN_ANNOUNCE_ALL_ALLHOSTS) ->
    translate:translate(Lang, <<"Send announcement to all users on all hosts">>);
get_title(Lang, ?NS_ADMIN_ANNOUNCE) ->
    translate:translate(Lang, <<"Send announcement to all online users">>);
get_title(Lang, ?NS_ADMIN_ANNOUNCE_ALLHOSTS) ->
    translate:translate(Lang, <<"Send announcement to all online users on all hosts">>);
get_title(Lang, ?NS_ADMIN_SET_MOTD) ->
    translate:translate(Lang, <<"Set message of the day and send to online users">>);
get_title(Lang, ?NS_ADMIN_SET_MOTD_ALLHOSTS) ->
    translate:translate(Lang, <<"Set message of the day on all hosts and send to online users">>);
get_title(Lang, ?NS_ADMIN_EDIT_MOTD) ->
    translate:translate(Lang, <<"Update message of the day (don't send)">>);
get_title(Lang, ?NS_ADMIN_EDIT_MOTD_ALLHOSTS) ->
    translate:translate(Lang, <<"Update message of the day on all hosts (don't send)">>);
get_title(Lang, ?NS_ADMIN_DELETE_MOTD) ->
    translate:translate(Lang, <<"Delete message of the day">>);
get_title(Lang, ?NS_ADMIN_DELETE_MOTD_ALLHOSTS) ->
    translate:translate(Lang, <<"Delete message of the day on all hosts">>).

-spec translate(binary(), binary()) -> binary().
translate(Lang, Msg) ->
    LLang = ascii_tolower(Lang),
    case ets:lookup(translations, {LLang, Msg}) of
      [{_, Trans}] -> Trans;
      _ ->
	  ShortLang = case str:tokens(LLang, <<"-">>) of
			[] -> LLang;
			[SL | _] -> SL
		      end,
	  case ShortLang of
	    <<"en">> -> Msg;
	    LLang -> translate(Msg);
	    _ ->
		case ets:lookup(translations, {ShortLang, Msg}) of
		  [{_, Trans}] -> Trans;
		  _ -> translate(Msg)
		end
	  end
    end.

#xmlel{
    name = <<"item">>,
    attrs = [
        {<<"jid">>, Server},
        {<<"node">>, <<"http://www.example.com/protocol/messager#upgrade-full">>},
        {<<"name">>, translate:translate(Lang, <<"Make a complete upgrade">>)}
    ],
    children = []
}

erlc $EJABBERD_SRC/contrib/extract_translations/extract_translations.erl

root@4850618fe551:~/ejabberd/contrib/extract_translations# ./prepare-translation.sh -h
Options:
  -langall
  -lang LANGUAGE_FILE
  -srcmsg2po LANGUAGE   Construct .msg file using source code to PO file
  -src2pot              Generate template POT file from source code
  -popot2po LANGUAGE    Update PO file with template POT file
  -po2msg LANGUAGE      Export PO file to MSG file
  -updateall            Generate POT and update all PO
Example:
  ./prepare-translation.sh -lang es.msg

root@4850618fe551:~/ejabberd# ./contrib/extract_translations/prepare-translation.sh -src2pot
./contrib/extract_translations/prepare-translation.sh: line 183: msguniq: command not found

aptitude install -y gettext

root@4850618fe551:~/ejabberd# ./contrib/extract_translations/prepare-translation.sh -src2pot

./contrib/extract_translations/prepare-translation.sh -po2msg zh

root@4850618fe551:~/ejabberd# make
/usr/lib/erlang/bin/escript rebar skip_deps=true compile
==> rel (compile)
==> ejabberd (compile)
Compiled src/mod_online_users.erl
Compiled src/mod_gbox_messager.erl
Compiled src/mod_cputime.erl
Compiled src/mod_system_information.erl

cp ebin/*.beam /lib/ejabberd/ebin
cp priv/*.msg /lib/ejabberd/priv/msgs

ejabberdctl restart

<iq type='get' to='xmpp.myserver.info' from='root@xmpp.myserver.info' xml:lang='zh' xmlns='jabber:client'>
  <query xmlns='http://jabber.org/protocol/disco#items' node='http://jabber.org/protocol/commands'/>
</iq>