Question

我正在尝试在Erlang中实现分布式环，其中每个节点都将存储数据。

我的想法是创建一个gen_server模块 node_ring ，它将在环中提供节点状态：

-record(nodestate, {id, hostname, previd, nextid, prevnodename, nextnodename, data}).

接下来，我通过以下方式创建了虚拟主机：

werl -sname node -setcookie cook
werl -sname node1 -setcookie cook
werl -sname node2 -setcookie cook

在第一个节点： node @ Machine 我启动环中的第一个项目：

**(node@Machine)1> node_ring:start_link()**

功能：

start_link() ->
    {Hostname, Id} = {'node@Machine', 0},
    {ok, Pid} = gen_server:start_link({local, ?MODULE}, ?MODULE, [first, Hostname, Id], []).

和

init([first, Hostname, Id]) ->          
            State = #nodestate{id = Id, hostname = Hostname, previd = Id, nextid = Id, prevnode = Hostname, nextnode = Hostname, data = dict:new()},
            {ok, State}.

在下一个节点中：**(node1@Machine)1>**我想启动相同的模块node_ring，但我不知道如何将它与环中的前一项相关联，以及下一个节点将如何知道哪个节点和node_ring已启动。

你能解释一下我，如何在Erlang中制作分布式铃声？我知道有一些像Riak这样的实现系统。我查看了源代码，但我对分布式Erlang编程很新，我不明白。

Answer 1

分布式系统编程很难。这很难理解。很难正确实施。

riak_core的源代码一开始很难理解。以下是一些帮助我更好地理解riak_core的资源：

Where to Start with Riak Core（特别是Ryan Zezeski的Try Try Try）
project-fifo中的任何riak_core项目。 howl可能是构建在riak_core之上的最小项目，相当容易理解。
了解riak_core的核心是一致的哈希算法，允许它以统一的方式使用分区分发数据并在整个环中工作：Why Riak Just Works
- 前段时间我写了erlang-ryng这是一个环的通用一致哈希算法处理程序。在环形环境中理解一致哈希的目的可能会有所帮助。
了解riak_pipe如何运作也有助于我更好地掌握如何以统一的方式分配工作。

关于＆＃34;难以正确实施＆＃34;，您可以阅读Jepsen posts by aphyr，了解主要数据库和分布式存储系统之前或之前存在问题的示例和案例自己的实施。

也就是说，这是Erlang中一个非常简单的环实现，但是它仍然有很多漏洞可以在下面解决：

-module(node_ring).
-behaviour(gen_server).

% Public API
-export([start_link/0]).
-export([erase/1]).
-export([find/1]).
-export([store/2]).

% Ring API
-export([join/1]).
-export([nodes/0]).
-export([read/1]).
-export([write/1]).
-export([write/2]).

% gen_server
-export([init/1]).
-export([handle_call/3]).
-export([handle_cast/2]).
-export([handle_info/2]).
-export([terminate/2]).
-export([code_change/3]).

-record(state, {
    node = node()        :: node(),
    ring = ordsets:new() :: ordsets:ordset(node()),
    data = dict:new()    :: dict:dict(term(), term())
}).

% Public API
start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

erase(Key) ->
    write({erase, Key}).

find(Key) ->
    read({find, Key}).

store(Key, Value) ->
    write({store, Key, Value}).

% Ring API
join(Node) ->
    gen_server:call(?MODULE, {join, Node}).

nodes() ->
    gen_server:call(?MODULE, nodes).

read(Request) ->
    gen_server:call(?MODULE, {read, Request}).

write(Request) ->
    gen_server:call(?MODULE, {write, Request}).

write(Node, Request) ->
    gen_server:call(?MODULE, {write, Node, Request}).

% gen_server
init([]) ->
    State = #state{},
    {ok, State}.

handle_call({join, Node}, _From, State=#state{node=Node}) ->
    {reply, ok, State};
handle_call({join, Peer}, From, State=#state{node=Node, ring=Ring}) ->
    case net_adm:ping(Peer) of
        pong ->
            case ordsets:is_element(Peer, Ring) of
                true ->
                    {reply, ok, State};
                false ->
                    monitor_node(Peer, true),
                    NewRing = ordsets:add_element(Peer, Ring),
                    spawn(fun() ->
                        rpc:multicall(Ring, ?MODULE, join, [Peer])
                    end),
                    spawn(fun() ->
                        Reply = rpc:call(Peer, ?MODULE, join, [Node]),
                        gen_server:reply(From, Reply)
                    end),
                    {noreply, State#state{ring=NewRing}}
            end;
        pang ->
            {reply, {error, connection_failed}, State}
    end;
handle_call(nodes, _From, State=#state{node=Node, ring=Ring}) ->
    {reply, ordsets:add_element(Node, Ring), State};
handle_call({read, Request}, From, State) ->
    handle_read(Request, From, State);
handle_call({write, Request}, From, State=#state{node=Node, ring=Ring}) ->
    spawn(fun() ->
        rpc:multicall(Ring, ?MODULE, write, [Node, Request])
    end),
    handle_write(Request, From, State);
handle_call({write, Node, _Request}, _From, State=#state{node=Node}) ->
    {reply, ok, State};
handle_call({write, _Peer, Request}, From, State) ->
    handle_write(Request, From, State);
handle_call(_Request, _From, State) ->
    {reply, ignore, State}.

handle_cast(_Request, State) ->
    {noreply, State}.

handle_info({nodedown, Peer}, State=#state{ring=Ring}) ->
    NewRing = ordsets:del_element(Peer, Ring),
    {noreply, State#state{ring=NewRing}};
handle_info(_Info, State) ->
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

%% @private
handle_read({find, Key}, _From, State=#state{data=Data}) ->
    {reply, dict:find(Key, Data), State}.

%% @private
handle_write({erase, Key}, _From, State=#state{data=Data}) ->
    {reply, ok, State#state{data=dict:erase(Key, Data)}};
handle_write({store, Key, Value}, _From, State=#state{data=Data}) ->
    {reply, ok, State#state{data=dict:store(Key, Value, Data)}}.

如果我们启动3个不同的节点，-sname设置为node0，node1和node2：

erl -sname node0 -setcookie cook -run node_ring start_link
erl -sname node1 -setcookie cook -run node_ring start_link
erl -sname node2 -setcookie cook -run node_ring start_link

以下是我们如何将节点加入环网：

(node0@localhost)1> node_ring:nodes().
['node0@localhost']
(node0@localhost)2> node_ring:join('node1@localhost').
ok
(node0@localhost)3> node_ring:nodes().
['node0@localhost', 'node1@localhost']

如果我们在node_ring:nodes()上运行node1，我们会：

(node1@localhost)1> node_ring:nodes().
['node0@localhost', 'node1@localhost']

现在让我们转到node2并加入另外两个节点之一：

(node2@localhost)1> node_ring:nodes().
['node2@localhost']
(node2@localhost)2> node_ring:join('node0localhost').
ok
(node2@localhost)3> node_ring:nodes().
['node0@localhost', 'node1@localhost',
 'node2@localhost']

注意node0和node1如何添加到node2，即使我们只在联接中指定了node0。这意味着如果我们有数百个节点，我们只需要加入其中一个节点即可加入整个环。

现在我们可以在任何节点上使用store(Key, Value)，它将被复制到另外两个节点：

(node0@localhost)4> node_ring:store(mykey, myvalue).
ok

让我们先试试mykey来自其他两个node1：

(node1@localhost)2> node_ring:find(mykey).
{ok,myvalue}

然后node2：

(node2@localhost)4> node_ring:find(mykey).
{ok,myvalue}

让我们在erase(Key)上使用node2并尝试在其他节点上再次阅读密钥：

(node2@localhost)5> node_ring:erase(mykey).
ok

在node0：

(node0@localhost)5> node_ring:find(mykey).
error

在node1：

(node1@localhost)3> node_ring:find(mykey).
error

真棒！我们有一个分布式分散环，可以作为一个简单的键/值存储！这很容易，一点都不难！只要我们没有任何节点发生故障，数据包丢失，网络分区，添加到环上的节点或其他形式的混乱，我们就会在这里提供近乎完美的解决方案。然而，实际上，你必须考虑所有这些事情，以便拥有一个不会让你疯狂的系统。

以下是我们的小node_ring无法处理的事情的简短示例：

node1关闭
node0存储密钥a和值1
node1回来加入戒指
node1尝试查找密钥a

首先，让我们杀死node1。如果我们检查node0上的节点：

(node0@localhost)6> node_ring:nodes().
['node0@localhost','node2@localhost']

并node2：

(node2@localhost)6> node_ring:nodes().
['node0@localhost','node2@localhost']

我们发现node1已自动从环中删除。让我们在node0上存储一些内容：

(node0@localhost)7> node_ring:store(a, 1).
ok

从node2：

(node2@localhost)7> node_ring:find(a).
{ok,1}

让我们再次启动node1并加入铃声：

(node1@localhost)1> node_ring:join('node0@localhost').
ok
(node1@localhost)2> node_ring:nodes().
['node0@localhost','node1@localhost',
 'node2@localhost']
(node1@localhost)3> node_ring:find(a).
error

哎呀，我们在整个环中都有不一致的数据。在我们决定我们希望我们的小node_ring在这些不同情况下的行为（比如我们是否希望它的行为像AP或CP系统）之前，需要进一步研究其他分布式系统和CAP theorem

分布式分散环

1 个答案: