cosmetics

4 files changed, 39 insertions, 37 deletions

diff --git a/include/rabbit.hrl b/include/rabbit.hrl
index cf33b6fd66..0d75310b11 100644
--- a/include/rabbit.hrl
+++ b/include/rabbit.hrl
@@ -51,7 +51,8 @@
 
 -record(exchange, {name, type, durable, auto_delete, arguments}).
 
--record(amqqueue, {name, durable, auto_delete, exclusive_owner = none, arguments, pid}).
+-record(amqqueue, {name, durable, auto_delete, exclusive_owner = none,
+                   arguments, pid}).
 
 %% mnesia doesn't like unary records, so we add a dummy 'value' field
 -record(route, {binding, value = const}).
diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index 7c2d558188..703300720e 100644
--- a/src/rabbit_amqqueue.erl
+++ b/src/rabbit_amqqueue.erl
@@ -65,8 +65,8 @@
       'ok' | {'error', [{'error' | 'exit' | 'throw', any()}]}).
 
 -spec(start/0 :: () -> 'ok').
--spec(declare/5 :: (queue_name(), boolean(), boolean(), amqp_table(), maybe(pid())) ->
-             amqqueue()).
+-spec(declare/5 :: (queue_name(), boolean(), boolean(), amqp_table(),
+                    maybe(pid())) -> amqqueue()).
 -spec(lookup/1 :: (queue_name()) -> {'ok', amqqueue()} | not_found()).
 -spec(with/2 :: (queue_name(), qfun(A)) -> A | not_found()).
 -spec(with_or_die/2 :: (queue_name(), qfun(A)) -> A).
diff --git a/src/rabbit_amqqueue_process.erl b/src/rabbit_amqqueue_process.erl
index d731aa2208..d4f3cb7dbf 100644
--- a/src/rabbit_amqqueue_process.erl
+++ b/src/rabbit_amqqueue_process.erl
@@ -484,8 +484,8 @@ i(pid, _) ->
     self();
 i(owner_pid, #q{q = #amqqueue{exclusive_owner = none}}) ->
     '';
-i(owner_pid, #q{q = #amqqueue{exclusive_owner = ReaderPid}}) ->
-    ReaderPid;
+i(owner_pid, #q{q = #amqqueue{exclusive_owner = ExclusiveOwner}}) ->
+    ExclusiveOwner;
 i(exclusive_consumer_pid, #q{exclusive_consumer = none}) ->
     '';
 i(exclusive_consumer_pid, #q{exclusive_consumer = {ChPid, _ConsumerTag}}) ->
@@ -533,7 +533,7 @@ handle_call({init, Recover}, From,
                         noreply(
                           State#q{backing_queue_state =
                                       BQ:init(QName, IsDurable, Recover)});
-                   Q1 ->
+                    Q1 ->
                         {stop, normal, Q1, State}
                 end
         end,
@@ -642,18 +642,16 @@ handle_call({basic_consume, NoAck, ChPid, LimiterPid,
         ok ->
             C = #cr{consumer_count = ConsumerCount} = ch_record(ChPid),
             Consumer = #consumer{tag = ConsumerTag,
-                                 ack_required = not(NoAck)},
+                                 ack_required = not NoAck},
             store_ch_record(C#cr{consumer_count = ConsumerCount +1,
                                  limiter_pid = LimiterPid}),
-            if ConsumerCount == 0 ->
-                    ok = rabbit_limiter:register(LimiterPid, self());
-               true ->
-                    ok
-            end,
-            ExclusiveConsumer =
-                if ExclusiveConsume -> {ChPid, ConsumerTag};
-                   true             -> ExistingHolder
-                end,
+            ok = case ConsumerCount of
+                     0    -> rabbit_limiter:register(LimiterPid, self());
+                     true -> ok
+                 end,
+            ExclusiveConsumer = if ExclusiveConsume -> {ChPid, ConsumerTag};
+                                   true             -> ExistingHolder
+                                end,
             State1 = State#q{has_had_consumers = true,
                              exclusive_consumer = ExclusiveConsumer},
             ok = maybe_send_reply(ChPid, OkMsg),
@@ -817,7 +815,7 @@ handle_cast({set_maximum_since_use, Age}, State) ->
     noreply(State).
 
 handle_info({'DOWN', _MonitorRef, process, DownPid, _Reason},
-            State = #q{q= #amqqueue{ exclusive_owner = DownPid}}) ->
+            State = #q{q = #amqqueue{exclusive_owner = DownPid}}) ->
     %% Exclusively owned queues must disappear with their owner.
     {stop, normal, State};
 handle_info({'DOWN', _MonitorRef, process, DownPid, _Reason}, State) ->
diff --git a/src/rabbit_channel.erl b/src/rabbit_channel.erl
index 040f7c7ce2..d72cc7ed3f 100644
--- a/src/rabbit_channel.erl
+++ b/src/rabbit_channel.erl
@@ -303,9 +303,9 @@ with_exclusive_access_or_die(QName, ReaderPid, F) ->
       QName,
       fun(Q) ->
               case Q of
-                  #amqqueue{ exclusive_owner = none} ->
+                  #amqqueue{exclusive_owner = none} ->
                       F(Q);
-                  #amqqueue{ exclusive_owner = ReaderPid } ->
+                  #amqqueue{exclusive_owner = ReaderPid} ->
                       F(Q);
                   _ ->
                       rabbit_misc:protocol_error(
@@ -683,15 +683,15 @@ handle_method(#'exchange.delete'{exchange = ExchangeNameBin,
             return_ok(State, NoWait,  #'exchange.delete_ok'{})
     end;
 
-handle_method(#'queue.declare'{queue = QueueNameBin,
-                               passive = false,
-                               durable = Durable,
-                               exclusive = ExclusiveDeclare,
+handle_method(#'queue.declare'{queue       = QueueNameBin,
+                               passive     = false,
+                               durable     = Durable,
+                               exclusive   = ExclusiveDeclare,
                                auto_delete = AutoDelete,
-                               nowait = NoWait,
-                               arguments = Args},
-              _, State = #ch { virtual_host = VHostPath,
-                               reader_pid = ReaderPid }) ->
+                               nowait      = NoWait,
+                               arguments   = Args},
+              _, State = #ch{virtual_host = VHostPath,
+                             reader_pid   = ReaderPid}) ->
     Owner = case ExclusiveDeclare of
                 true  -> ReaderPid;
                 false -> none
@@ -712,15 +712,16 @@ handle_method(#'queue.declare'{queue = QueueNameBin,
                         Matched;
                     %% exclusivity trumps non-equivalence arbitrarily
                     #amqqueue{name = QueueName, exclusive_owner = ExclusiveOwner}
-                    when ExclusiveOwner =/= Owner ->
-                        rabbit_misc:protocol_error(resource_locked,
-                                                   "cannot obtain exclusive access to locked ~s",
-                                                   [rabbit_misc:rs(QueueName)]);
+                      when ExclusiveOwner =/= Owner ->
+                        rabbit_misc:protocol_error(
+                          resource_locked,
+                          "cannot obtain exclusive access to locked ~s",
+                          [rabbit_misc:rs(QueueName)]);
                     #amqqueue{name = QueueName} ->
-                        rabbit_misc:protocol_error(channel_error,
-                                                   "parameters for ~s not equivalent",
-                                                   [rabbit_misc:rs(QueueName)])
-                    end
+                        rabbit_misc:protocol_error(
+                          channel_error, "parameters for ~s not equivalent",
+                          [rabbit_misc:rs(QueueName)])
+                end
         end,
     Q = case rabbit_amqqueue:with(
                rabbit_misc:r(VHostPath, queue, QueueNameBin),
@@ -733,8 +734,10 @@ handle_method(#'queue.declare'{queue = QueueNameBin,
                     end,
                 QueueName = rabbit_misc:r(VHostPath, queue, ActualNameBin),
                 check_configure_permitted(QueueName, State),
-                Finish(rabbit_amqqueue:declare(QueueName, Durable, AutoDelete, Args, Owner));
-            Found -> Found
+                Finish(rabbit_amqqueue:declare(QueueName, Durable, AutoDelete,
+                                               Args, Owner));
+            Found ->
+                Found
         end,
     return_queue_declare_ok(State, NoWait, Q);