Split back up into lots of little txs.

3 files changed, 31 insertions, 41 deletions

diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index 7c49277884..c71a21f101 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -95,45 +95,32 @@
                     routing_key, arguments]).
 
 recover(XNames, QNames) ->
-    XBs = rabbit_misc:execute_mnesia_transaction(
-            fun () ->
-                    XBs = recover_internal(XNames, QNames),
-                    callback_bindings(true, XBs),
-                    XBs
-            end),
-    callback_bindings(false, XBs),
-    ok.
-
-recover_internal(XNames, QNames) ->
     XNameSet = sets:from_list(XNames),
     QNameSet = sets:from_list(QNames),
-    lists:foldl(
-      fun (Route = #route{binding = B = #binding{source = Src}}, Acc) ->
+    rabbit_misc:table_fold(
+      fun (Route = #route{binding = B}, _Acc) ->
               case should_recover(B, XNameSet, QNameSet) of
                   true  -> ok = sync_transient_binding(
                                   Route, fun mnesia:write/3),
-                           rabbit_misc:dict_cons(Src, B, Acc);
-                  false -> Acc
+                           B;
+                  false -> none
               end
-      end, dict:new(),
-      mnesia:select(rabbit_durable_route, [{'$1', [], ['$1']}])).
+      end,
+      fun (none, _Tx) ->
+              ok;
+          (B = #binding{source = Src}, Tx) ->
+              {ok, X} = rabbit_exchange:lookup(Src),
+              rabbit_exchange:callback(X, add_bindings, [Tx, X, [B]])
+      end,
+      none, rabbit_durable_route),
+    ok.
 
-should_recover(B = #binding{destination = Dst = #resource{ kind = Kind }},
+should_recover(#binding{destination = Dst = #resource{ kind = Kind }},
                XNameSet, QNameSet) ->
-    case mnesia:read({rabbit_route, B}) of
-        [] -> sets:is_element(Dst, case Kind of
-                                       exchange -> XNameSet;
-                                       queue    -> QNameSet
-                                   end);
-        _  -> false
-    end.
-
-callback_bindings(Tx, XBs) ->
-    dict:map(fun (XName, Bindings) ->
-                     {ok, X} = rabbit_exchange:lookup(XName),
-                     rabbit_exchange:callback(X, add_bindings,
-                                              [Tx, X, Bindings])
-             end, XBs).
+    sets:is_element(Dst, case Kind of
+                             exchange -> XNameSet;
+                             queue    -> QNameSet
+                         end).
 
 exists(Binding) ->
     binding_action(
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index b39fe32ca7..bc2d5b29d4 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -90,11 +90,12 @@ recover() ->
                               [X | Acc];
                        [_] -> Acc
                    end
-           end, [], rabbit_durable_exchange),
-    rabbit_misc:execute_pre_post_mnesia_tx(
-      fun (Tx) ->
-              [rabbit_exchange:callback(X, create, [Tx, X]) || X <- Xs]
-      end),
+           end,
+           fun (Acc = [X | _], Tx) ->
+                   rabbit_exchange:callback(X, create, [Tx, X]),
+                   Acc
+           end,
+           [], rabbit_durable_exchange),
     [XName || #exchange{name = XName} <- Xs].
 
 callback(#exchange{type = XType}, Fun, Args) ->
diff --git a/src/rabbit_misc.erl b/src/rabbit_misc.erl
index 8927020f15..28c4596e53 100644
--- a/src/rabbit_misc.erl
+++ b/src/rabbit_misc.erl
@@ -39,7 +39,7 @@
 -export([ensure_ok/2]).
 -export([makenode/1, nodeparts/1, cookie_hash/0, tcp_name/3]).
 -export([upmap/2, map_in_order/2]).
--export([table_fold/3]).
+-export([table_fold/4]).
 -export([dirty_read_all/1, dirty_foreach_key/2, dirty_dump_log/1]).
 -export([read_term_file/1, write_term_file/2]).
 -export([append_file/2, ensure_parent_dirs_exist/1]).
@@ -148,7 +148,8 @@
         -> atom()).
 -spec(upmap/2 :: (fun ((A) -> B), [A]) -> [B]).
 -spec(map_in_order/2 :: (fun ((A) -> B), [A]) -> [B]).
--spec(table_fold/3 :: (fun ((any(), A) -> A), A, atom()) -> A).
+-spec(table_fold/4 :: (fun ((any(), A) -> A), fun ((A, boolean()) -> A), A,
+                                                  atom()) -> A).
 -spec(dirty_read_all/1 :: (atom()) -> [any()]).
 -spec(dirty_foreach_key/2 :: (fun ((any()) -> any()), atom())
                              -> 'ok' | 'aborted').
@@ -473,14 +474,15 @@ map_in_order(F, L) ->
 %% around the lot.
 %%
 %% We ignore entries that have been modified or removed.
-table_fold(F, Acc0, TableName) ->
+table_fold(Fun, PrePostCommitFun, Acc0, TableName) ->
     lists:foldl(
       fun (E, Acc) -> execute_mnesia_transaction(
                         fun () -> case mnesia:match_object(TableName, E, read) of
                                       [] -> Acc;
-                                      _  -> F(E, Acc)
+                                      _  -> Fun(E, Acc)
                                   end
-                        end)
+                        end,
+                        PrePostCommitFun)
       end, Acc0, dirty_read_all(TableName)).
 
 dirty_read_all(TableName) ->