cosmetics and indentation onlybug23445

3 files changed, 113 insertions, 120 deletions

diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index 44bf0ba2..20097a7d 100644
--- a/src/rabbit_amqqueue.erl
+++ b/src/rabbit_amqqueue.erl
@@ -452,17 +452,17 @@ internal_delete1(QueueName) ->
 
 internal_delete(QueueName) ->
     rabbit_misc:execute_mnesia_transaction(
-           fun () ->
-                   case mnesia:wread({rabbit_queue, QueueName}) of
-                       []  -> {error, not_found};
-                       [_] -> internal_delete1(QueueName)
-                   end
-           end,
-           fun ({error, _} = Err, _Tx) ->
-                   Err;
-               (Deletions, Tx) ->
-                   ok = rabbit_binding:process_deletions(Deletions, Tx)
-           end).
+      fun () ->
+              case mnesia:wread({rabbit_queue, QueueName}) of
+                  []  -> {error, not_found};
+                  [_] -> internal_delete1(QueueName)
+              end
+      end,
+      fun ({error, _} = Err, _Tx) ->
+              Err;
+          (Deletions, Tx) ->
+              ok = rabbit_binding:process_deletions(Deletions, Tx)
+      end).
 
 maybe_run_queue_via_backing_queue(QPid, Fun) ->
     gen_server2:call(QPid, {maybe_run_queue_via_backing_queue, Fun}, infinity).
@@ -493,12 +493,12 @@ on_node_down(Node) ->
                                 node(Pid) == Node]))
       end,
       fun (Deletions, Tx) ->
-          rabbit_binding:process_deletions(
-            lists:foldl(
-              fun rabbit_binding:combine_deletions/2,
-              rabbit_binding:new_deletions(),
-              Deletions),
-            Tx)
+              rabbit_binding:process_deletions(
+                lists:foldl(
+                  fun rabbit_binding:combine_deletions/2,
+                  rabbit_binding:new_deletions(),
+                  Deletions),
+                Tx)
       end).
 
 delete_queue(QueueName) ->
diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index 740af5ac..74fd00b7 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -118,10 +118,9 @@ recover() ->
 
 exists(Binding) ->
     binding_action(
-      Binding,
-      fun (_Src, _Dst, B) ->
-          rabbit_misc:const(mnesia:read({rabbit_route, B}) /= [])
-      end).
+      Binding, fun (_Src, _Dst, B) ->
+                       rabbit_misc:const(mnesia:read({rabbit_route, B}) /= [])
+               end).
 
 add(Binding) -> add(Binding, fun (_Src, _Dst) -> ok end).
 
@@ -129,61 +128,56 @@ remove(Binding) -> remove(Binding, fun (_Src, _Dst) -> ok end).
 
 add(Binding, InnerFun) ->
     binding_action(
-           Binding,
-           fun (Src, Dst, B) ->
-                   %% this argument is used to check queue exclusivity;
-                   %% in general, we want to fail on that in preference to
-                   %% anything else
-                   case InnerFun(Src, Dst) of
-                       ok ->
-                           case mnesia:read({rabbit_route, B}) of
-                               []  -> ok = sync_binding(
-                                             B, all_durable([Src, Dst]),
-                                             fun mnesia:write/3),
-                                      fun (Tx) ->
-                                          ok = rabbit_exchange:callback(
-                                                   Src, add_binding,
-                                                   [Tx, Src, B]),
-                                          rabbit_event:notify_if(
-                                                   not Tx,
-                                                   binding_created, info(B))
-                                      end;
-                               [_] -> fun rabbit_misc:const_ok/1
-                           end;
-                       {error, _} = Err ->
-                           rabbit_misc:const(Err)
-                   end
-           end).
+      Binding,
+      fun (Src, Dst, B) ->
+              %% this argument is used to check queue exclusivity;
+              %% in general, we want to fail on that in preference to
+              %% anything else
+              case InnerFun(Src, Dst) of
+                  ok ->
+                      case mnesia:read({rabbit_route, B}) of
+                          []  -> ok = sync_binding(B, all_durable([Src, Dst]),
+                                                   fun mnesia:write/3),
+                                 fun (Tx) ->
+                                         ok = rabbit_exchange:callback(
+                                                Src, add_binding, [Tx, Src, B]),
+                                         rabbit_event:notify_if(
+                                           not Tx, binding_created, info(B))
+                                 end;
+                          [_] -> fun rabbit_misc:const_ok/1
+                      end;
+                  {error, _} = Err ->
+                      rabbit_misc:const(Err)
+              end
+      end).
 
 remove(Binding, InnerFun) ->
     binding_action(
-           Binding,
-           fun (Src, Dst, B) ->
-               Result =
-                   case mnesia:match_object(rabbit_route, #route{binding = B},
-                                            write) of
-                       [] ->
-                           {error, binding_not_found};
-                       [_] ->
-                           case InnerFun(Src, Dst) of
-                               ok ->
-                                   ok = sync_binding(
-                                          B, all_durable([Src, Dst]),
-                                          fun mnesia:delete_object/3),
-                                   {ok,
-                                    maybe_auto_delete(B#binding.source,
-                                                      [B], new_deletions())};
-                               {error, _} = E ->
-                                   E
-                           end
-                   end,
-                   case Result of
-                       {error, _} = Err ->
-                           rabbit_misc:const(Err);
-                       {ok, Deletions} ->
-                           fun (Tx) -> ok = process_deletions(Deletions, Tx) end
-                   end
-           end).
+      Binding,
+      fun (Src, Dst, B) ->
+              Result =
+                  case mnesia:match_object(rabbit_route, #route{binding = B},
+                                           write) of
+                      [] ->
+                          {error, binding_not_found};
+                      [_] ->
+                          case InnerFun(Src, Dst) of
+                              ok ->
+                                  ok = sync_binding(B, all_durable([Src, Dst]),
+                                                    fun mnesia:delete_object/3),
+                                  {ok, maybe_auto_delete(B#binding.source,
+                                                         [B], new_deletions())};
+                              {error, _} = E ->
+                                  E
+                          end
+                  end,
+              case Result of
+                  {error, _} = Err ->
+                      rabbit_misc:const(Err);
+                  {ok, Deletions} ->
+                      fun (Tx) -> ok = process_deletions(Deletions, Tx) end
+              end
+      end).
 
 list(VHostPath) ->
     VHostResource = rabbit_misc:r(VHostPath, '_'),
@@ -427,15 +421,16 @@ merge_entry({X1, Deleted1, Bindings1}, {X2, Deleted2, Bindings2}) ->
 process_deletions(Deletions, Tx) ->
     dict:fold(
       fun (_XName, {X, Deleted, Bindings}, ok) ->
-          FlatBindings = lists:flatten(Bindings),
-          [rabbit_event:notify_if(not Tx, binding_deleted, info(B)) ||
-              B <- FlatBindings],
-          case Deleted of
-              not_deleted -> rabbit_exchange:callback(X, remove_bindings,
-                                                      [Tx, X, FlatBindings]);
-              deleted     -> rabbit_event:notify_if(not Tx, exchange_deleted,
-                                                    [{name, X#exchange.name}]),
-                             rabbit_exchange:callback(X, delete,
-                                                      [Tx, X, FlatBindings])
-          end
+              FlatBindings = lists:flatten(Bindings),
+              [rabbit_event:notify_if(not Tx, binding_deleted, info(B)) ||
+                  B <- FlatBindings],
+              case Deleted of
+                  not_deleted ->
+                      rabbit_exchange:callback(X, remove_bindings,
+                                               [Tx, X, FlatBindings]);
+                  deleted ->
+                      rabbit_event:notify_if(not Tx, exchange_deleted,
+                                             [{name, X#exchange.name}]),
+                      rabbit_exchange:callback(X, delete, [Tx, X, FlatBindings])
+              end
       end, ok, Deletions).
diff --git a/src/rabbit_exchange.erl b/src/rabbit_exchange.erl
index 0ec57564..83c26e68 100644
--- a/src/rabbit_exchange.erl
+++ b/src/rabbit_exchange.erl
@@ -126,32 +126,29 @@ declare(XName, Type, Durable, AutoDelete, Internal, Args) ->
     %% We want to upset things if it isn't ok
     ok = (type_to_module(Type)):validate(X),
     rabbit_misc:execute_mnesia_transaction(
-           fun () ->
-                   case mnesia:wread({rabbit_exchange, XName}) of
-                       [] ->
-                           ok = mnesia:write(rabbit_exchange, X, write),
-                           ok = case Durable of
-                                    true ->
-                                        mnesia:write(rabbit_durable_exchange,
+      fun () ->
+              case mnesia:wread({rabbit_exchange, XName}) of
+                  [] ->
+                      ok = mnesia:write(rabbit_exchange, X, write),
+                      ok = case Durable of
+                               true  -> mnesia:write(rabbit_durable_exchange,
                                                      X, write);
-                                    false ->
-                                        ok
+                               false -> ok
                            end,
-                           {new, X};
-                       [ExistingX] ->
-                           {existing, ExistingX}
-                   end
-           end,
-           fun ({new, Exchange}, Tx) ->
-                   callback(Exchange, create, [Tx, Exchange]),
-                   rabbit_event:notify_if(
-                       not Tx, exchange_created, info(Exchange)),
-                   Exchange;
-               ({existing, Exchange}, _Tx) ->
-                   Exchange;
-               (Err, _Tx) ->
-                   Err
-           end).
+                      {new, X};
+                  [ExistingX] ->
+                      {existing, ExistingX}
+              end
+      end,
+      fun ({new, Exchange}, Tx) ->
+              callback(Exchange, create, [Tx, Exchange]),
+              rabbit_event:notify_if(not Tx, exchange_created, info(Exchange)),
+              Exchange;
+          ({existing, Exchange}, _Tx) ->
+              Exchange;
+          (Err, _Tx) ->
+              Err
+      end).
 
 %% Used with atoms from records; e.g., the type is expected to exist.
 type_to_module(T) ->
@@ -290,18 +287,19 @@ call_with_exchange(XName, Fun, PrePostCommitFun) ->
       end, PrePostCommitFun).
 
 delete(XName, IfUnused) ->
-    call_with_exchange(XName,
-        case IfUnused of
-            true  -> fun conditional_delete/1;
-            false -> fun unconditional_delete/1
-        end,
-        fun ({deleted, X, Bs, Deletions}, Tx) ->
-                ok = rabbit_binding:process_deletions(
-                       rabbit_binding:add_deletion(
-                         XName, {X, deleted, Bs}, Deletions), Tx);
-            (Error = {error, _InUseOrNotFound}, _Tx) ->
-                Error
-        end).
+    call_with_exchange(
+      XName,
+      case IfUnused of
+          true  -> fun conditional_delete/1;
+          false -> fun unconditional_delete/1
+      end,
+      fun ({deleted, X, Bs, Deletions}, Tx) ->
+              ok = rabbit_binding:process_deletions(
+                     rabbit_binding:add_deletion(
+                       XName, {X, deleted, Bs}, Deletions), Tx);
+          (Error = {error, _InUseOrNotFound}, _Tx) ->
+              Error
+      end).
 
 maybe_auto_delete(#exchange{auto_delete = false}) ->
     not_deleted;