Use names, not exchanges / queues.

4 files changed, 23 insertions, 23 deletions

diff --git a/src/rabbit.erl b/src/rabbit.erl
index 6b6731a3..fe392c5f 100644
--- a/src/rabbit.erl
+++ b/src/rabbit.erl
@@ -460,34 +460,34 @@ boot_delegate() ->
     rabbit_sup:start_child(delegate_sup, [Count]).
 
 recover() ->
-    Xs = rabbit_exchange:recover(),
-    Qs = rabbit_amqqueue:start(),
-    Bs = rabbit_binding:recover(Xs, Qs),
-    {RecXBs, NoRecSrcBs} = filter_recovered_exchanges(Xs, Bs),
-    ok = recovery_callbacks(RecXBs, NoRecSrcBs).
+    XNames = rabbit_exchange:recover(),
+    QNames = rabbit_amqqueue:start(),
+    Bs = rabbit_binding:recover(XNames, QNames),
+    {RecXBs, NoRecXBs} = filter_recovered_exchanges(XNames, Bs),
+    ok = recovery_callbacks(RecXBs, NoRecXBs).
 
 filter_recovered_exchanges(Xs, Bs) ->
-    RecXs = dict:from_list([{XName, X} || X = #exchange{name = XName} <- Xs]),
+    RecXs = sets:from_list(Xs),
     lists:foldl(
       fun (B = #binding{source = Src}, {RecXBs, NoRecXBs}) ->
-              case dict:find(Src, RecXs) of
-                  {ok, X} -> {dict:append(X, B, RecXBs), NoRecXBs};
-                  error   -> {RecXBs, dict:append(Src, B, NoRecXBs)}
+              case sets:is_element(Src, RecXs) of
+                  true  -> {dict:append(Src, B, RecXBs), NoRecXBs};
+                  false -> {RecXBs, dict:append(Src, B, NoRecXBs)}
               end
       end, {dict:new(), dict:new()}, Bs).
 
 recovery_callbacks(RecXBs, NoRecXBs) ->
+    CB = fun (Tx, F, XBs) ->
+                 dict:map(fun (XName, Bs) ->
+                                  {ok, X} = rabbit_exchange:lookup(XName),
+                                  rabbit_exchange:callback(X, F, [Tx, X, Bs])
+                          end, XBs)
+         end,
     rabbit_misc:execute_mnesia_transaction(
       fun () -> ok end,
       fun (ok, Tx) ->
-              dict:map(fun (X, Bs) ->
-                               rabbit_exchange:callback(X, start, [Tx, X, Bs])
-                       end, RecXBs),
-              dict:map(fun (Src, Bs) ->
-                               {ok, X} = rabbit_exchange:lookup(Src),
-                               rabbit_exchange:callback(X, add_bindings,
-                                                        [Tx, X, Bs])
-                       end, NoRecXBs)
+              CB(Tx, start, RecXBs),
+              CB(Tx, add_bindings, NoRecXBs)
       end),
     ok.
 
diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index 2618c1f5..6267b823 100644
--- a/src/rabbit_amqqueue.erl
+++ b/src/rabbit_amqqueue.erl
@@ -186,7 +186,7 @@ find_durable_queues() ->
 
 recover_durable_queues(DurableQueues) ->
     Qs = [start_queue_process(Q) || Q <- DurableQueues],
-    [Q || Q <- Qs,
+    [Q#amqqueue.name || Q <- Qs,
           gen_server2:call(Q#amqqueue.pid, {init, true}, infinity) == {new, Q}].
 
 declare(QueueName, Durable, AutoDelete, Args, Owner) ->
diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index fff9016c..47793920 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -94,12 +94,12 @@
                     destination_name, destination_kind,
                     routing_key, arguments]).
 
-recover(Xs, Qs) ->
-    XNames = sets:from_list([Name || #exchange{name = Name} <- Xs]),
-    QNames = sets:from_list([Name || #amqqueue{name = Name} <- Qs]),
+recover(XsL, QsL) ->
+    Xs = sets:from_list(XsL),
+    Qs = sets:from_list(QsL),
     rabbit_misc:table_fold(
       fun (Route = #route{binding = B}, Acc) ->
-              case should_recover(B, XNames, QNames) of
+              case should_recover(B, Xs, Qs) of
                   true  -> {_, Rev} = route_with_reverse(Route),
                            ok = mnesia:write(rabbit_route, Route, write),
                            ok = mnesia:write(rabbit_reverse_route, Rev, write),
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index fa837d0c..e05a8812 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -87,7 +87,7 @@ recover() ->
       fun (X = #exchange{name = XName}, Acc) ->
               case mnesia:read({rabbit_exchange, XName}) of
                   []  -> ok = mnesia:write(rabbit_exchange, X, write),
-                         [X | Acc];
+                         [XName | Acc];
                   [_] -> Acc
               end
       end, [], rabbit_durable_exchange).