Indentation

3 files changed, 46 insertions, 44 deletions

diff --git a/src/rabbit_access_control.erl b/src/rabbit_access_control.erl
index f2007137..f574507b 100644
--- a/src/rabbit_access_control.erl
+++ b/src/rabbit_access_control.erl
@@ -330,10 +330,13 @@ add_vhost(VHostPath) ->
           end),
     rabbit_log:info("Added vhost ~p~n", [VHostPath]),
     case R of
-        {ok, Xs} -> [{rabbit_exchange:maybe_callback(Type, create, [X]),
-                      rabbit_event:notify(exchange_created,
-                                          rabbit_exchange:info(X))} ||
-                     X = #exchange{type = Type} <- Xs], ok;
+        {ok, Xs} -> lists:map(
+                        fun(X = #exchange{type = Type}) ->
+                            rabbit_event:notify(exchange_created,
+                                                rabbit_exchange:info(X))
+                            rabbit_exchange:maybe_callback(Type, create, [X]),
+                        end, Xs),
+                    ok;
         _        -> R
     end.
 
diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index 6a5d6ddd..5131400c 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -128,7 +128,7 @@ remove(Binding) -> remove(Binding, fun (_Src, _Dst) -> ok end).
 add(Binding, InnerFun) ->
     case binding_action(
            Binding,
-           fun (Src = #exchange{ type = Type }, Dst, B) ->
+           fun (Src = #exchange{type = Type}, Dst, B) ->
                    %% this argument is used to check queue exclusivity;
                    %% in general, we want to fail on that in preference to
                    %% anything else
@@ -138,7 +138,7 @@ add(Binding, InnerFun) ->
                                []  -> ok = sync_binding(
                                              B, all_durable([Src, Dst]),
                                              fun mnesia:write/3),
-                                      rabbit_exchange:maybe_callback(
+                                      ok = rabbit_exchange:maybe_callback(
                                              Type, add_binding, [Src, B]),
                                       {new, Src, B};
                                [_] -> {existing, Src, B}
@@ -147,8 +147,8 @@ add(Binding, InnerFun) ->
                            E
                    end
            end) of
-        {new, Src = #exchange{ type = Type }, B} ->
-            rabbit_exchange:maybe_callback(Type, add_binding, [Src, B]),
+        {new, Src = #exchange{type = Type}, B} ->
+            ok = rabbit_exchange:maybe_callback(Type, add_binding, [Src, B]),
             rabbit_event:notify(binding_created, info(B));
         {existing, _, _} ->
             ok;
@@ -427,29 +427,29 @@ process_deletions(Deletions) ->
     NonTxFun =
         if Tx     -> fun(_X, _D, _B) -> ok end;
            not Tx ->
-            fun (#exchange{name = XName}, Deleted, FlatBindings) ->
-                [rabbit_event:notify(binding_deleted, info(B))
-                 || B <- FlatBindings],
-                case Deleted of
-                    not_deleted -> ok;
-                    deleted     -> rabbit_event:notify(exchange_deleted,
-                                                       [{name, XName}])
-                end
-            end
+               fun (#exchange{name = XName}, Deleted, FlatBindings) ->
+                   [rabbit_event:notify(binding_deleted, info(B)) ||
+                    B <- FlatBindings],
+                   case Deleted of
+                       not_deleted -> ok;
+                       deleted     -> rabbit_event:notify(exchange_deleted,
+                                                          [{name, XName}])
+                   end
+               end
         end,
     Fun =
-      fun (X = #exchange{type = Type}, Deleted, FlatBindings) ->
-              case Deleted of
-                  not_deleted -> rabbit_exchange:maybe_callback(
-                                     Type, remove_bindings, [X, FlatBindings]);
-                  deleted     -> rabbit_exchange:maybe_callback(
-                                     Type, delete, [X, FlatBindings])
-              end
-      end,
+        fun (X = #exchange{type = Type}, Deleted, FlatBindings) ->
+            case Deleted of
+                not_deleted -> rabbit_exchange:maybe_callback(
+                                   Type, remove_bindings, [X, FlatBindings]);
+                deleted     -> rabbit_exchange:maybe_callback(
+                                   Type, delete, [X, FlatBindings])
+            end
+        end,
     dict:fold(
-      fun (_XName, {X, Deleted, Bindings}, ok) ->
-              FlatBindings = lists:flatten(Bindings),
-              ok = Fun(X, Deleted, FlatBindings),
-              NonTxFun(X, Deleted, FlatBindings)
-      end, ok, Deletions).
+        fun (_XName, {X, Deleted, Bindings}, ok) ->
+            FlatBindings = lists:flatten(Bindings),
+            NonTxFun(X, Deleted, FlatBindings)
+            Fun(X, Deleted, FlatBindings),
+        end, ok, Deletions).
 
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index 752f7935..07883118 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -120,12 +120,10 @@ declare(XName, Type, Durable, AutoDelete, Args) ->
                   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.
+    %% We want to upset things if it isn't ok
     TypeModule = type_to_module(Type),
     ok = TypeModule:validate(X),
-    case {rabbit_misc:execute_mnesia_transaction(
+    case rabbit_misc:execute_mnesia_transaction(
            fun () ->
                    case mnesia:wread({rabbit_exchange, XName}) of
                        [] ->
@@ -137,18 +135,18 @@ declare(XName, Type, Durable, AutoDelete, Args) ->
                                     false ->
                                         ok
                            end,
-                           maybe_callback(Type, create, [X]),
-                           {new, X};
+                           ok = maybe_callback(Type, create, [X]),
+                           {new, X, mnesia:is_transaction()};
                        [ExistingX] ->
                            {existing, ExistingX}
                    end
-           end), mnesia:is_transaction()} of
-        {{new, X}, false}     -> maybe_callback(Type, create, [X]),
-                                 rabbit_event:notify(exchange_created, info(X)),
-                                 X;
-        {{new, X}, true}      -> X;
-        {{existing, X}, _}    -> X;
-        Err                   -> Err
+           end) of
+        {new, X, false} -> ok = maybe_callback(Type, create, [X]),
+                           rabbit_event:notify(exchange_created, info(X)),
+                           X;
+        {new, X, true}  -> X;
+        {existing, X}   -> X;
+        Err             -> Err
     end.
 
 %% Used with atoms from records; e.g., the type is expected to exist.
@@ -308,6 +306,7 @@ maybe_auto_delete(#exchange{auto_delete = true} = X) ->
 
 %% Possible callback, depending on whether mnesia is in a transaction
 %% and whether transactional callbacks were requested by the exchange
+%% The type is expected to exist.
 maybe_callback(XType, Fun, Args) ->
     {ok, [Module, ModTx]} = rabbit_exchange_type_registry:lookup_module(XType),
     Tx = mnesia:is_transaction(),
@@ -325,5 +324,5 @@ unconditional_delete(X = #exchange{name = XName, type = Type}) ->
     ok = mnesia:delete({rabbit_durable_exchange, XName}),
     ok = mnesia:delete({rabbit_exchange, XName}),
     Bindings = rabbit_binding:remove_for_source(XName),
-    maybe_callback(Type, delete, [X, lists:flatten(Bindings)]),
+    ok = maybe_callback(Type, delete, [X, lists:flatten(Bindings)]),
     {deleted, X, Bindings, rabbit_binding:remove_for_destination(XName)}.