refactor: move all serial manipulation code into 'exchange' module

2 files changed, 22 insertions, 24 deletions

diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index 1336223244..1092948a1a 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -133,7 +133,7 @@ add(Binding, InnerFun) ->
 add_notify(Src, Dst, B) ->
     ok = sync_binding(B, all_durable([Src, Dst]), fun mnesia:write/3),
     ok = rabbit_exchange:callback(Src, add_binding, [transaction, Src, B]),
-    Serial = serial(Src),
+    Serial = rabbit_exchange:serial(Src),
     fun () ->
             ok = rabbit_exchange:callback(Src, add_binding, [Serial, Src, B]),
             ok = rabbit_event:notify(binding_created, info(B))
@@ -410,7 +410,7 @@ process_deletions(Deletions) ->
                 fun (_XName, {X, Deleted, Bindings}, Acc) ->
                         FlatBindings = lists:flatten(Bindings),
                         pd_callback(transaction, X, Deleted, FlatBindings),
-                        dict:store(X, serial(X), Acc)
+                        dict:store(X, rabbit_exchange:serial(X), Acc)
                 end, Deletions, dict:new()),
     fun() ->
             dict:fold(
@@ -433,18 +433,3 @@ pd_callback(Arg, X, Deleted, Bindings) ->
                                          not_deleted -> remove_bindings;
                                          deleted     -> delete
                                      end, [Arg, X, Bindings]).
-
-serial(X) ->
-    case rabbit_exchange:serialise_events(X) of
-        true  -> next_serial(X);
-        false -> none
-    end.
-
-next_serial(#exchange{name = Name}) ->
-    Serial = case mnesia:read(rabbit_exchange_serial, Name, write) of
-                 []                             -> 1;
-                 [#exchange_serial{serial = S}] -> S + 1
-             end,
-    mnesia:write(rabbit_exchange_serial,
-                 #exchange_serial{name = Name, serial = Serial}, write),
-    Serial.
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index 3bd667a583..3c42ed3c45 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -22,9 +22,9 @@
          assert_equivalence/6, assert_args_equivalence/2, check_type/1,
          lookup/1, lookup_or_die/1, list/1,
          info_keys/0, info/1, info/2, info_all/1, info_all/2,
-         publish/2, delete/2, serialise_events/1]).
-%% this must be run inside a mnesia tx
--export([maybe_auto_delete/1]).
+         publish/2, delete/2]).
+%% these must be run inside a mnesia tx
+-export([maybe_auto_delete/1, serial/1]).
 
 %%----------------------------------------------------------------------------
 
@@ -72,10 +72,11 @@
         (name(), boolean())-> 'ok' |
                               rabbit_types:error('not_found') |
                               rabbit_types:error('in_use')).
--spec(serialise_events/1:: (rabbit_types:exchange()) -> boolean()).
 -spec(maybe_auto_delete/1::
         (rabbit_types:exchange())
         -> 'not_deleted' | {'deleted', rabbit_binding:deletions()}).
+-spec(serial/1:: (rabbit_types:exchange()) -> 'none' | pos_integer()).
+
 -endif.
 
 %%----------------------------------------------------------------------------
@@ -298,9 +299,6 @@ delete0(XName, Fun) ->
               end
       end).
 
-serialise_events(#exchange{type = XType}) ->
-    apply(type_to_module(XType), serialise_events, []).
-
 maybe_auto_delete(#exchange{auto_delete = false}) ->
     not_deleted;
 maybe_auto_delete(#exchange{auto_delete = true} = X) ->
@@ -322,6 +320,21 @@ unconditional_delete(X = #exchange{name = XName}) ->
     Bindings = rabbit_binding:remove_for_source(XName),
     {deleted, X, Bindings, rabbit_binding:remove_for_destination(XName)}.
 
+serial(#exchange{name = XName, type = XType}) ->
+    case (type_to_module(XType)):serialise_events() of
+        true  -> next_serial(XName);
+        false -> none
+    end.
+
+next_serial(XName) ->
+    Serial1 = case mnesia:read(rabbit_exchange_serial, XName, write) of
+                  []                                  -> 1;
+                  [#exchange_serial{serial = Serial}] -> Serial + 1
+              end,
+    mnesia:write(rabbit_exchange_serial,
+                 #exchange_serial{name = XName, serial = Serial1}, write),
+    Serial1.
+
 %% Used with atoms from records; e.g., the type is expected to exist.
 type_to_module(T) ->
     {ok, Module} = rabbit_registry:lookup_module(exchange, T),