PROSAGA码农传奇-SOA/RPC-分布式Erlang：multicall超过请求的超时

<div class =“post-text”itemprop =“text”>
  
    的
      我解决了这个问题。
    </强>
  
  
    我已经使用了自己的multicall实现
     <code>
 gen_server:call
 </code>
    
基本思想是在单独的进程中使用gen_server：call（）调用所有节点。并收集这些电话的结果。通过从调用进程的邮箱接收消息来进行收集。
  
  
    为了控制超时，我计算超时到期时的截止日期，然后将其用作参考点来计算超时
     <code>
 after
 </code>
     在
     <code>
 receive
 </code>
    。
  
  
    的
      履行
    </强>
  
  
    主要功能是：
  
   <pre>
 <code>
 multicall(Nodes, Name, Req, Timeout) ->
 Refs = lists:map(fun(Node) -> call_node(Node, Name, Req, Timeout) end, Nodes),
 Results = read_all(Timeout, Refs),
 PosResults = [ { Node, Result } || { ok, { ok, { Node, Result } } } <- Results ],
 { PosResults, calc_bad_nodes(Nodes, PosResults) }.

</code>
 </pre>
  
    这里的想法是调用所有节点并在一个超时内等待所有结果。
  
  
    从生成的进程执行调用一个节点。它捕获了所使用的出口
     <code>
 gen_server:call
 </code>
     如果有错误。
  
   <pre>
 <code>
 call_node(Node, Name, Req, Timeout) ->
 Ref = make_ref(),
 Self = self(),
 spawn_link(fun() ->
 try
 Result = gen_server:call({Name,Node},Req,Timeout),
 Self ! { Ref, { ok, { Node, Result } } }
 catch
 exit:Exit ->
 Self ! { Ref, { error, { 'EXIT', Exit } } }
 end
 end),
 Ref.

</code>
 </pre>
  
    坏节点计算为在Timout内没有响应的节点
  
   <pre>
 <code>
 calc_bad_nodes(Nodes, PosResults) ->
 { GoodNodes, _ } = lists:unzip(PosResults),
 [ BadNode || BadNode <- Nodes, not lists:member(BadNode, GoodNodes) ].

</code>
 </pre>
  
    通过使用Timeout读取邮箱来收集结果
  
   <pre>
 <code>
 read_all(ReadList, Timeout) ->
 Now = erlang:monotonic_time(millisecond),
 Deadline = Now + Timeout,
 read_all_impl(ReadList, Deadline, []).

</code>
 </pre>
  
    实施将一直显示，直到截止日期未发生
  
   <pre>
 <code>
 read_all_impl([], _, Results) ->
 lists:reverse(Results);
read_all_impl([ W | Rest ], expired, Results) ->
 R = read(0, W),
 read_all_impl(Rest, expired, [R | Results ]);
read_all_impl([ W | Rest ] = L, Deadline, Results) ->
 Now = erlang:monotonic_time(millisecond),
 case Deadline - Now of
 Timeout when Timeout > 0 ->
 R = read(Timeout, W),
 case R of
 { ok, _ } ->
 read_all_impl(Rest, Deadline, [ R | Results ]);
 { error, { read_timeout, _ } } ->
 read_all_impl(Rest, expired, [ R | Results ])
 end;
 Timeout when Timeout =< 0 ->
 read_all_impl(L, expired, Results)
 end.

</code>
 </pre>
  
    只使用Timeout从邮箱接收一次读取。
  
   <pre>
 <code>
 read(Timeout, Ref) ->
 receive
 { Ref, Result } ->
 { ok, Result }
 after Timeout ->
 { error, { read_timeout, Timeout } }
 end.

</code>
 </pre>
  
    进一步改进：
  
  <UL>
    <LI>
      rpc模块产生单独的进程，以避免后期答案的垃圾。因此，在这个multicall函数中做同样的事情会很有用
    </LI>
    <LI>
       <code>
 infinity
 </code>
       超时可能会以明显的方式处理
    </LI>
  </UL>
</DIV>