Changes

4 files changed, 30 insertions, 32 deletions

diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index aa697f07..f5fd9a65 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -144,13 +144,12 @@ serial(#exchange{name = XName} = X) ->
     end.
 
 declare(XName, Type, Durable, AutoDelete, Internal, Args) ->
-    X0 = rabbit_policy:set(#exchange{name        = XName,
-                                     type        = Type,
-                                     durable     = Durable,
-                                     auto_delete = AutoDelete,
-                                     internal    = Internal,
-                                     arguments   = Args}),
-    X = rabbit_exchange_decorator:record(X0, rabbit_exchange_decorator:list()),
+    X = rabbit_policy:set(#exchange{name        = XName,
+                                    type        = Type,
+                                    durable     = Durable,
+                                    auto_delete = AutoDelete,
+                                    internal    = Internal,
+                                    arguments   = Args}),
     XT = type_to_module(Type),
     %% We want to upset things if it isn't ok
     ok = XT:validate(X),
@@ -316,20 +315,20 @@ route(#exchange{name = #resource{virtual_host = VHost, name = RName} = XName,
         {<<"">>, []} ->
             %% Optimisation
             [rabbit_misc:r(VHost, queue, RK) || RK <- lists:usort(RKs)];
-        {_, RDecorators} ->
-            lists:usort(route1(Delivery, RDecorators, {[X], XName, []}))
+        {_, SelectedDecorators} ->
+            lists:usort(route1(Delivery, SelectedDecorators, {[X], XName, []}))
     end.
 
 route1(_, _, {[], _, QNames}) ->
     QNames;
-route1(Delivery, RDecorators,
+route1(Delivery, Decorators,
        {[X = #exchange{type = Type} | WorkList], SeenXs, QNames}) ->
     ExchangeDests  = (type_to_module(Type)):route(X, Delivery),
-    RDecorateDests = process_decorators(X, RDecorators, Delivery),
+    DecorateDests = process_decorators(X, Decorators, Delivery),
     AlternateDests = process_alternate(X, ExchangeDests),
-    route1(Delivery, RDecorators,
+    route1(Delivery, Decorators,
            lists:foldl(fun process_route/2, {WorkList, SeenXs, QNames},
-                       AlternateDests ++ RDecorateDests  ++ ExchangeDests)).
+                       AlternateDests ++ DecorateDests  ++ ExchangeDests)).
 
 process_alternate(#exchange{arguments = []}, _Results) -> %% optimisation
     [];
diff --git a/src/rabbit_exchange_decorator.erl b/src/rabbit_exchange_decorator.erl
index cdbc42bb..3748a844 100644
--- a/src/rabbit_exchange_decorator.erl
+++ b/src/rabbit_exchange_decorator.erl
@@ -18,7 +18,7 @@
 
 -include("rabbit.hrl").
 
--export([list/0, select/2, record/2]).
+-export([list/0, select/2, set/1]).
 
 %% This is like an exchange type except that:
 %%
@@ -59,8 +59,8 @@
 
 %% Decorators can optionally implement route/2 which allows additional
 %% destinations to be added to the routing decision.
--callback route(rabbit_types:exchange(), rabbit_types:delivery()) ->
-    [rabbit_amqqueue:name() | rabbit_exchange:name()] | ok.
+%% -callback route(rabbit_types:exchange(), rabbit_types:delivery()) ->
+%%     [rabbit_amqqueue:name() | rabbit_exchange:name()] | ok.
 
 %% Whether the decorator wishes to receive callbacks for the exchange
 %% none:no callbacks, noroute:all callbacks except route, all:all callbacks
@@ -87,14 +87,14 @@ list() -> [M || {_, M} <- rabbit_registry:lookup_all(exchange_decorator)].
 select(all,   {Route, NoRoute})  -> Route ++ NoRoute;
 select(route, {Route, _NoRoute}) -> Route.
 
-%% record active decorators in an exchange
-record(X, Decorators) ->
-    X#exchange{decorators =
-      lists:foldl(fun (D, {Route, NoRoute}) ->
-                          Callbacks = D:active_for(X),
-                          {cons_if_eq(all,     Callbacks, D, Route),
-                           cons_if_eq(noroute, Callbacks, D, NoRoute)}
-                  end, {[], []}, Decorators)}.
+set(X) ->
+    X#exchange{
+      decorators =
+        lists:foldl(fun (D, {Route, NoRoute}) ->
+                            Callbacks = D:active_for(X),
+                            {cons_if_eq(all,     Callbacks, D, Route),
+                             cons_if_eq(noroute, Callbacks, D, NoRoute)}
+                    end, {[], []}, rabbit_exchange_decorator:list())}.
 
 cons_if_eq(Select,  Select, Item,  List) -> [Item | List];
 cons_if_eq(_Select, _Other, _Item, List) -> List.
diff --git a/src/rabbit_policy.erl b/src/rabbit_policy.erl
index 22e9bdac..d276c2fb 100644
--- a/src/rabbit_policy.erl
+++ b/src/rabbit_policy.erl
@@ -46,7 +46,8 @@ name0(undefined) -> none;
 name0(Policy)    -> pget(name, Policy).
 
 set(Q = #amqqueue{name = Name}) -> Q#amqqueue{policy = set0(Name)};
-set(X = #exchange{name = Name}) -> X#exchange{policy = set0(Name)}.
+set(X = #exchange{name = Name}) -> rabbit_exchange_decorator:set(
+                                     X#exchange{policy = set0(Name)}).
 
 set0(Name = #resource{virtual_host = VHost}) -> match(Name, list(VHost)).
 
@@ -156,10 +157,9 @@ notify_clear(VHost, <<"policy">>, _Name) ->
 
 update_policies(VHost) ->
     Policies = list(VHost),
-    Decorators = rabbit_exchange_decorator:list(),
     {Xs, Qs} = rabbit_misc:execute_mnesia_transaction(
                  fun() ->
-                         {[update_exchange(X, Policies, Decorators) ||
+                         {[update_exchange(X, Policies) ||
                               X <- rabbit_exchange:list(VHost)],
                           [update_queue(Q, Policies) ||
                               Q <- rabbit_amqqueue:list(VHost)]}
@@ -168,16 +168,15 @@ update_policies(VHost) ->
     [catch notify(Q) || Q <- Qs],
     ok.
 
-update_exchange(X = #exchange{name = XName, policy = OldPolicy},
-                Policies, Decorators) ->
+update_exchange(X = #exchange{name = XName, policy = OldPolicy}, Policies) ->
     case match(XName, Policies) of
         OldPolicy ->
             no_change;
         NewPolicy ->
             rabbit_exchange:update(
               XName, fun(X1) ->
-                             rabbit_exchange_decorator:record(
-                               X1#exchange{policy = NewPolicy}, Decorators)
+                             rabbit_exchange_decorator:set(
+                               X1#exchange{policy = NewPolicy})
                      end),
             {X, X#exchange{policy = NewPolicy}}
     end.
diff --git a/src/rabbit_tests.erl b/src/rabbit_tests.erl
index 91f560cb..93e2d046 100644
--- a/src/rabbit_tests.erl
+++ b/src/rabbit_tests.erl
@@ -565,7 +565,7 @@ test_topic_matching() ->
                       name = <<"test_exchange">>},
     X0 = #exchange{name = XName, type = topic, durable = false,
                    auto_delete = false, arguments = []},
-    X = rabbit_exchange_decorator:record(X0, []),
+    X = rabbit_exchange_decorator:set(X0),
     %% create
     rabbit_exchange_type_topic:validate(X),
     exchange_op_callback(X, create, []),