diff options
| -rw-r--r-- | src/rabbit_binding.erl | 61 | ||||
| -rw-r--r-- | src/rabbit_exchange.erl | 68 | ||||
| -rw-r--r-- | src/rabbit_router.erl | 4 |
3 files changed, 66 insertions, 67 deletions
diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl index bb29580fd4..19150fa9f9 100644 --- a/src/rabbit_binding.erl +++ b/src/rabbit_binding.erl @@ -129,8 +129,8 @@ add(Binding, InnerFun) -> E end end) of - {new, Exchange = #exchange{ type = Type }, B} -> - ok = (type_to_module(Type)):add_binding(Exchange, B), + {new, X = #exchange{ type = Type }, B} -> + ok = (type_to_module(Type)):add_binding(X, B), rabbit_event:notify(binding_created, info(B)); {existing, _, _} -> ok; @@ -181,8 +181,8 @@ list(VHostPath) -> [B || #route{binding = B} <- mnesia:dirty_match_object(rabbit_route, Route)]. -list_for_exchange(ExchangeName) -> - Route = #route{binding = #binding{exchange_name = ExchangeName, _ = '_'}}, +list_for_exchange(XName) -> + Route = #route{binding = #binding{exchange_name = XName, _ = '_'}}, [B || #route{binding = B} <- mnesia:dirty_match_object(rabbit_route, Route)]. @@ -192,8 +192,8 @@ list_for_queue(QueueName) -> mnesia:dirty_match_object(rabbit_reverse_route, reverse_route(Route))]. -list_for_exchange_and_queue(ExchangeName, QueueName) -> - Route = #route{binding = #binding{exchange_name = ExchangeName, +list_for_exchange_and_queue(XName, QueueName) -> + Route = #route{binding = #binding{exchange_name = XName, queue_name = QueueName, _ = '_'}}, [B || #route{binding = B} <- mnesia:dirty_match_object(rabbit_route, @@ -222,14 +222,14 @@ info_all(VHostPath) -> map(VHostPath, fun (B) -> info(B) end). info_all(VHostPath, Items) -> map(VHostPath, fun (B) -> info(B, Items) end). -has_for_exchange(ExchangeName) -> - Match = #route{binding = #binding{exchange_name = ExchangeName, _ = '_'}}, +has_for_exchange(XName) -> + Match = #route{binding = #binding{exchange_name = XName, _ = '_'}}, %% we need to check for durable routes here too in case a bunch of %% routes to durable queues have been removed temporarily as a %% result of a node failure contains(rabbit_route, Match) orelse contains(rabbit_durable_route, Match). -remove_for_exchange(ExchangeName) -> +remove_for_exchange(XName) -> [begin ok = mnesia:delete_object(rabbit_reverse_route, reverse_route(Route), write), @@ -237,7 +237,7 @@ remove_for_exchange(ExchangeName) -> Route#route.binding end || Route <- mnesia:match_object( rabbit_route, - #route{binding = #binding{exchange_name = ExchangeName, + #route{binding = #binding{exchange_name = XName, _ = '_'}}, write)]. @@ -249,11 +249,11 @@ remove_transient_for_queue(QueueName) -> %%---------------------------------------------------------------------------- -binding_action(Binding = #binding{exchange_name = ExchangeName, +binding_action(Binding = #binding{exchange_name = XName, queue_name = QueueName, args = Arguments}, Fun) -> call_with_exchange_and_queue( - ExchangeName, QueueName, + XName, QueueName, fun (X, Q) -> SortedArgs = rabbit_misc:sort_field_table(Arguments), Fun(X, Q, Binding#binding{args = SortedArgs}) @@ -270,10 +270,10 @@ sync_binding(Binding, Durable, Fun) -> ok = Fun(rabbit_reverse_route, ReverseRoute, write), ok. -call_with_exchange_and_queue(Exchange, Queue, Fun) -> +call_with_exchange_and_queue(XName, QueueName, Fun) -> rabbit_misc:execute_mnesia_transaction( - fun () -> case {mnesia:read({rabbit_exchange, Exchange}), - mnesia:read({rabbit_queue, Queue})} of + fun () -> case {mnesia:read({rabbit_exchange, XName}), + mnesia:read({rabbit_queue, QueueName})} of {[X], [Q]} -> Fun(X, Q); {[ ], [_]} -> {error, exchange_not_found}; {[_], [ ]} -> {error, queue_not_found}; @@ -327,16 +327,15 @@ remove_for_queue(QueueName, FwdDeleteFun) -> group_bindings_and_auto_delete([], Acc) -> Acc; group_bindings_and_auto_delete( - [B = #binding{exchange_name = ExchangeName} | Bs], Acc) -> - group_bindings_and_auto_delete(ExchangeName, Bs, [B], Acc). + [B = #binding{exchange_name = XName} | Bs], Acc) -> + group_bindings_and_auto_delete(XName, Bs, [B], Acc). group_bindings_and_auto_delete( - ExchangeName, [B = #binding{exchange_name = ExchangeName} | Bs], - Bindings, Acc) -> - group_bindings_and_auto_delete(ExchangeName, Bs, [B | Bindings], Acc); -group_bindings_and_auto_delete(ExchangeName, Removed, Bindings, Acc) -> - %% either Removed is [], or its head has a non-matching ExchangeName - [X] = mnesia:read({rabbit_exchange, ExchangeName}), + XName, [B = #binding{exchange_name = XName} | Bs], Bindings, Acc) -> + group_bindings_and_auto_delete(XName, Bs, [B | Bindings], Acc); +group_bindings_and_auto_delete(XName, Removed, Bindings, Acc) -> + %% either Removed is [], or its head has a non-matching XName + [X] = mnesia:read({rabbit_exchange, XName}), NewAcc = [{{rabbit_exchange:maybe_auto_delete(X), X}, Bindings} | Acc], group_bindings_and_auto_delete(Removed, NewAcc). @@ -359,20 +358,20 @@ reverse_route(#route{binding = Binding}) -> reverse_route(#reverse_route{reverse_binding = Binding}) -> #route{binding = reverse_binding(Binding)}. -reverse_binding(#reverse_binding{exchange_name = Exchange, - queue_name = Queue, +reverse_binding(#reverse_binding{exchange_name = XName, + queue_name = QueueName, key = Key, args = Args}) -> - #binding{exchange_name = Exchange, - queue_name = Queue, + #binding{exchange_name = XName, + queue_name = QueueName, key = Key, args = Args}; -reverse_binding(#binding{exchange_name = Exchange, - queue_name = Queue, +reverse_binding(#binding{exchange_name = XName, + queue_name = QueueName, key = Key, args = Args}) -> - #reverse_binding{exchange_name = Exchange, - queue_name = Queue, + #reverse_binding{exchange_name = XName, + queue_name = QueueName, key = Key, args = Args}. diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl index 40bee25f8b..2a19d5b1c8 100644 --- a/src/rabbit_exchange.erl +++ b/src/rabbit_exchange.erl @@ -92,15 +92,15 @@ -define(INFO_KEYS, [name, type, durable, auto_delete, arguments]). recover() -> - Exs = rabbit_misc:table_fold( - fun (Exchange, Acc) -> - ok = mnesia:write(rabbit_exchange, Exchange, write), - [Exchange | Acc] - end, [], rabbit_durable_exchange), + Xs = rabbit_misc:table_fold( + fun (X, Acc) -> + ok = mnesia:write(rabbit_exchange, X, write), + [X | Acc] + end, [], rabbit_durable_exchange), Bs = rabbit_binding:recover(), recover_with_bindings( lists:keysort(#binding.exchange_name, Bs), - lists:keysort(#exchange.name, Exs), []). + lists:keysort(#exchange.name, Xs), []). recover_with_bindings([B = #binding{exchange_name = Name} | Rest], Xs = [#exchange{name = Name} | _], @@ -112,30 +112,30 @@ recover_with_bindings(Bs, [X = #exchange{type = Type} | Xs], Bindings) -> recover_with_bindings([], [], []) -> ok. -declare(ExchangeName, Type, Durable, AutoDelete, Args) -> - Exchange = #exchange{name = ExchangeName, - type = Type, - durable = Durable, - auto_delete = AutoDelete, - arguments = Args}, +declare(XName, Type, Durable, AutoDelete, Args) -> + X = #exchange{name = XName, + type = Type, + durable = Durable, + auto_delete = AutoDelete, + arguments = Args}, %% We want to upset things if it isn't ok; this is different from %% the other hooks invocations, where we tend to ignore the return %% value. TypeModule = type_to_module(Type), - ok = TypeModule:validate(Exchange), + ok = TypeModule:validate(X), case rabbit_misc:execute_mnesia_transaction( fun () -> - case mnesia:wread({rabbit_exchange, ExchangeName}) of + case mnesia:wread({rabbit_exchange, XName}) of [] -> - ok = mnesia:write(rabbit_exchange, Exchange, write), + ok = mnesia:write(rabbit_exchange, X, write), ok = case Durable of true -> mnesia:write(rabbit_durable_exchange, - Exchange, write); + X, write); false -> ok end, - {new, Exchange}; + {new, X}; [ExistingX] -> {existing, ExistingX} end @@ -257,20 +257,20 @@ publish(X = #exchange{type = Type}, Seen, Delivery) -> R end. -call_with_exchange(Exchange, Fun) -> +call_with_exchange(XName, Fun) -> rabbit_misc:execute_mnesia_transaction( - fun () -> case mnesia:read({rabbit_exchange, Exchange}) of + fun () -> case mnesia:read({rabbit_exchange, XName}) of [] -> {error, not_found}; [X] -> Fun(X) end end). -delete(ExchangeName, IfUnused) -> +delete(XName, IfUnused) -> Fun = case IfUnused of true -> fun conditional_delete/1; false -> fun unconditional_delete/1 end, - case call_with_exchange(ExchangeName, Fun) of + case call_with_exchange(XName, Fun) of {deleted, X = #exchange{type = Type}, Bs} -> (type_to_module(Type)):delete(X, Bs), ok; @@ -280,21 +280,21 @@ delete(ExchangeName, IfUnused) -> maybe_auto_delete(#exchange{auto_delete = false}) -> not_deleted; -maybe_auto_delete(#exchange{auto_delete = true} = Exchange) -> - case conditional_delete(Exchange) of - {error, in_use} -> not_deleted; - {deleted, Exchange, []} -> auto_deleted +maybe_auto_delete(#exchange{auto_delete = true} = X) -> + case conditional_delete(X) of + {error, in_use} -> not_deleted; + {deleted, X, []} -> auto_deleted end. -conditional_delete(Exchange = #exchange{name = ExchangeName}) -> - case rabbit_binding:has_for_exchange(ExchangeName) of - false -> unconditional_delete(Exchange); +conditional_delete(X = #exchange{name = XName}) -> + case rabbit_binding:has_for_exchange(XName) of + false -> unconditional_delete(X); true -> {error, in_use} end. -unconditional_delete(Exchange = #exchange{name = ExchangeName}) -> - Bindings = rabbit_binding:remove_for_exchange(ExchangeName), - ok = mnesia:delete({rabbit_durable_exchange, ExchangeName}), - ok = mnesia:delete({rabbit_exchange, ExchangeName}), - rabbit_event:notify(exchange_deleted, [{name, ExchangeName}]), - {deleted, Exchange, Bindings}. +unconditional_delete(X = #exchange{name = XName}) -> + Bindings = rabbit_binding:remove_for_exchange(XName), + ok = mnesia:delete({rabbit_durable_exchange, XName}), + ok = mnesia:delete({rabbit_exchange, XName}), + rabbit_event:notify(exchange_deleted, [{name, XName}]), + {deleted, X, Bindings}. diff --git a/src/rabbit_router.erl b/src/rabbit_router.erl index bfccb0daa5..bd57f73726 100644 --- a/src/rabbit_router.erl +++ b/src/rabbit_router.erl @@ -85,10 +85,10 @@ deliver(QPids, Delivery) -> %% TODO: This causes a full scan for each entry with the same exchange match_bindings(Name, Match) -> Query = qlc:q([QName || #route{binding = Binding = #binding{ - exchange_name = ExchangeName, + exchange_name = XName, queue_name = QName}} <- mnesia:table(rabbit_route), - ExchangeName == Name, + XName == Name, Match(Binding)]), lookup_qpids(mnesia:async_dirty(fun qlc:e/1, [Query])). |