Ping Riak nodes

pinger.erl

-module(pinger).

-export([ping/1,
         ping/3,
         pinglist/4,
         pingall/0,
         pingall/1,
         pingall/2
]).

ping(Node) ->
    Start = now(),
    Response = net_adm:ping(Node),
    End = now(),
    Elapsed = timer:now_diff(End, Start),
    io:format("Ping ~p responded ~p in ~b usec~n", [Node, Response, Elapsed]),
    {Response, Elapsed}.

ping(PPid, Node, {Good0, Bad0, Min0, Max0, Average0, Count}) ->
    {Good, Bad, Min, Max, Average} = case ping(Node) of
        {pong, Elapsed} ->
            {Good0 + 1, Bad0, min(Min0, Elapsed), max(Max0, Elapsed), (Average0 * Count + Elapsed)/(Count + 1)};
        _ ->
            {Good0, Bad0 + 1, Min0, Max0, Average0}
    end,
    Rslt = {Good, Bad, Min, Max, Average, Count + 1},
    PPid ! {self(), Node, Rslt}.

node_stats(Node, Stats) ->
    case dict:is_key(Node, Stats) of
        false ->
            {0, 0, none, 0, 0.0, 0};
        true ->
            dict:fetch(Node, Stats)
    end.

receive_results([], Stats) ->
    Stats;
receive_results([Pid|T], Stats0) ->
    Stats1 = receive
                 {Pid, Node, Rslt} -> dict:store(Node, Rslt, Stats0)
             end,
    receive_results(T, Stats1).

pinglist(_Nodes, _Delay, Stats, 0) -> Stats;
pinglist(Nodes, Delay, Stats, Count) ->
    Pids = [spawn(pinger, ping, [self(), Node, node_stats(Node, Stats)]) || Node <- Nodes],
    Stats1 = receive_results(Pids, Stats),
    timer:sleep(Delay),
    pinglist(Nodes, Delay, Stats1, Count - 1).

pingall() ->
  pingall(1).

pingall(Count) ->
  pingall(1000, Count).

pingall(Delay, Count) when is_integer(Delay), is_integer(Count), Count > 0 ->
 {ok,Ring} = riak_core_ring_manager:get_my_ring(),
 Members = riak_core_ring:all_members(Ring),
 Stats = pinglist(Members, Delay, dict:new(), Count),
 FinalStats = dict:to_list(Stats),
 [io:format("~p: ~b pong, ~b fail, ~p/~b/~f min/max/average usec, ~b pings sent~n", [Node, Good, Bad, Min, Max, Ave, Cnt]) || {Node, {Good, Bad, Min, Max, Ave, Cnt}} <- FinalStats].