rabbit_alarm: Prefer maps to dicts

This is not a functional change, just a refactor to eliminate dicts and
use maps instead. This cleans up some helper functions like
dict_append/3, and we can use map comprehensions in some places to
avoid intermediary lists.

Author: the-mikedavis

deps/rabbit/src/rabbit_alarm.erl

@@ -42,9 +42,9 @@
 
 %%----------------------------------------------------------------------------
 
--record(alarms, {alertees :: dict:dict(pid(), rabbit_types:mfargs()),
-                 alarmed_nodes :: dict:dict(node(), [resource_alarm_source()]),
-                 alarms :: [alarm()]}).
+-record(alarms, {alertees = #{} :: #{pid() => rabbit_types:mfargs()},
+                 alarmed_nodes = #{} :: #{node() => [resource_alarm_source()]},
+                 alarms = [] :: [alarm()]}).
 
 -export_type([alarm/0]).
 -type local_alarm() :: 'file_descriptor_limit'.
@@ -90,7 +90,7 @@ stop() -> ok.
 %% called like this: `apply(M, F, A ++ [Pid, Source, Alert])', where `Source'
 %% has the type of resource_alarm_source() and `Alert' has the type of resource_alert().
 
--spec register(pid(), rabbit_types:mfargs()) -> [atom()].
+-spec register(pid(), rabbit_types:mfargs()) -> [resource_alarm_source()].
 
 register(Pid, AlertMFA) ->
     gen_event:call(?SERVER, ?MODULE, {register, Pid, AlertMFA}, infinity).
@@ -177,12 +177,10 @@ remote_conserve_resources(Pid, Source, {false, _, _}) ->
 %%----------------------------------------------------------------------------
 
 init([]) ->
-    {ok, #alarms{alertees      = dict:new(),
-                 alarmed_nodes = dict:new(),
-                 alarms        = []}}.
+    {ok, #alarms{}}.
 
 handle_call({register, Pid, AlertMFA}, State = #alarms{alarmed_nodes = AN}) ->
-    {ok, lists:usort(lists:append([V || {_, V} <- dict:to_list(AN)])),
+    {ok, lists:usort(lists:append(maps:values(AN))),
      internal_register(Pid, AlertMFA, State)};
 
 handle_call(get_alarms, State) ->
@@ -236,14 +234,11 @@ handle_event({node_up, Node}, State) ->
     {ok, State};
 
 handle_event({node_down, Node}, #alarms{alarmed_nodes = AN} = State) ->
-    AlarmsForDeadNode = case dict:find(Node, AN) of
-                            {ok, V} -> V;
-                            error   -> []
-                        end,
+    AlarmsForDeadNode = maps:get(Node, AN, []),
     {ok, lists:foldr(fun(Source, AccState) ->
                              ?LOG_WARNING("~ts resource limit alarm cleared for dead node ~tp",
                                           [Source, Node]),
-                             maybe_alert(fun dict_unappend/3, Node, Source, false, AccState)
+                             maybe_alert(fun map_unappend/3, Node, Source, false, AccState)
                      end, State, AlarmsForDeadNode)};
 
 handle_event({register, Pid, AlertMFA}, State) ->
@@ -254,7 +249,7 @@ handle_event(_Event, State) ->
 
 handle_info({'DOWN', _MRef, process, Pid, _Reason},
             State = #alarms{alertees = Alertees}) ->
-    {ok, State#alarms{alertees = dict:erase(Pid, Alertees)}};
+    {ok, State#alarms{alertees = maps:remove(Pid, Alertees)}};
 
 handle_info(_Info, State) ->
     {ok, State}.
@@ -267,30 +262,25 @@ code_change(_OldVsn, State, _Extra) ->
 
 %%----------------------------------------------------------------------------
 
-dict_append(Key, Val, Dict) ->
-    L = case dict:find(Key, Dict) of
-            {ok, V} -> V;
-            error   -> []
-        end,
-    dict:store(Key, lists:usort([Val|L]), Dict).
-
-dict_unappend(Key, Val, Dict) ->
-    L = case dict:find(Key, Dict) of
-            {ok, V} -> V;
-            error   -> []
-        end,
+map_append(Key, Val, Map) ->
+    maps:update_with(Key, fun(Vs) -> [Val | Vs] end, [Val], Map).
 
+map_unappend(Key, Val, Map) ->
+    L = maps:get(Key, Map, []),
     case lists:delete(Val, L) of
-        [] -> dict:erase(Key, Dict);
-        X  -> dict:store(Key, X, Dict)
+        [] -> maps:remove(Key, Map);
+        X  -> Map#{Key := X}
     end.
 
 maybe_alert(UpdateFun, Node, Source, WasAlertAdded,
             State = #alarms{alarmed_nodes = AN,
                             alertees      = Alertees}) ->
     AN1 = UpdateFun(Node, Source, AN),
     %% Is alarm for Source still set on any node?
-    StillHasAlerts = lists:any(fun ({_Node, NodeAlerts}) -> lists:member(Source, NodeAlerts) end, dict:to_list(AN1)),
+    StillHasAlerts = rabbit_misc:maps_any(
+                       fun(_Node, NodeAlerts) ->
+                               lists:member(Source, NodeAlerts)
+                       end, AN1),
     case StillHasAlerts of
         true -> ok;
         false -> ?LOG_WARNING("~ts resource limit alarm cleared across the cluster", [Source])
@@ -311,22 +301,24 @@ alert_remote(Alert, Alertees, Source) ->
 
 alert(Alertees, Source, Alert, NodeComparator) ->
     Node = node(),
-    dict:fold(fun (Pid, {M, F, A}, ok) ->
-                      case NodeComparator(Node, node(Pid)) of
-                          true  -> apply(M, F, A ++ [Pid, Source, Alert]);
-                          false -> ok
-                      end
-              end, ok, Alertees).
+    maps:foreach(fun (Pid, {M, F, A}) ->
+                         case NodeComparator(Node, node(Pid)) of
+                             true  -> apply(M, F, A ++ [Pid, Source, Alert]);
+                             false -> ok
+                         end
+                 end, Alertees).
 
 internal_register(Pid, {M, F, A} = AlertMFA,
                   State = #alarms{alertees = Alertees}) ->
     _MRef = erlang:monitor(process, Pid),
-    _ = case dict:find(node(), State#alarms.alarmed_nodes) of
-        {ok, Sources} -> [apply(M, F, A ++ [Pid, R, {true, true, node()}]) || R <- Sources];
-        error          -> ok
+    Node = node(),
+    _ = case State#alarms.alarmed_nodes of
+        #{Node := Sources} ->
+            [apply(M, F, A ++ [Pid, R, {true, true, node()}]) || R <- Sources];
+        _ ->
+            ok
     end,
-    NewAlertees = dict:store(Pid, AlertMFA, Alertees),
-    State#alarms{alertees = NewAlertees}.
+    State#alarms{alertees = Alertees#{Pid => AlertMFA}}.
 
 handle_set_resource_alarm(Source, Node, State) ->
     ?LOG_WARNING(
@@ -335,7 +327,7 @@ handle_set_resource_alarm(Source, Node, State) ->
       "*** Publishers will be blocked until this alarm clears ***~n"
       "**********************************************************~n",
       [Source, Node]),
-    {ok, maybe_alert(fun dict_append/3, Node, Source, true, State)}.
+    {ok, maybe_alert(fun map_append/3, Node, Source, true, State)}.
 
 handle_set_alarm({file_descriptor_limit, []}, State) ->
     ?LOG_WARNING(
@@ -351,7 +343,7 @@ handle_set_alarm(Alarm, State) ->
 handle_clear_resource_alarm(Source, Node, State) ->
     ?LOG_WARNING("~ts resource limit alarm cleared on node ~tp",
                  [Source, Node]),
-    {ok, maybe_alert(fun dict_unappend/3, Node, Source, false, State)}.
+    {ok, maybe_alert(fun map_unappend/3, Node, Source, false, State)}.
 
 handle_clear_alarm(file_descriptor_limit, State) ->
     ?LOG_WARNING("file descriptor limit alarm cleared~n"),
@@ -361,14 +353,14 @@ handle_clear_alarm(Alarm, State) ->
     {ok, State}.
 
 is_node_alarmed(Source, Node, #alarms{alarmed_nodes = AN}) ->
-    case dict:find(Node, AN) of
-        {ok, Sources} ->
+    case AN of
+        #{Node := Sources} ->
             lists:member(Source, Sources);
-        error ->
+        _ ->
             false
     end.
 
 compute_alarms(#alarms{alarms = Alarms,
                    alarmed_nodes = AN}) ->
     Alarms ++ [ {{resource_limit, Source, Node}, []}
-                || {Node, Sources} <- dict:to_list(AN), Source <- Sources ].
+                || Node := Sources <- AN, Source <- Sources ].