Merge in default

5 files changed, 31 insertions, 14 deletions

diff --git a/src/file_handle_cache.erl b/src/file_handle_cache.erl
index 126b3f81..519c596d 100644
--- a/src/file_handle_cache.erl
+++ b/src/file_handle_cache.erl
@@ -584,6 +584,10 @@ prim_file_write(Hdl, Bytes) ->
 prim_file_sync(Hdl) ->
     file_handle_cache_stats:update(sync, fun() -> prim_file:sync(Hdl) end).
 
+prim_file_position(Hdl, NewOffset) ->
+    file_handle_cache_stats:update(
+      seek, fun() -> prim_file:position(Hdl, NewOffset) end).
+
 is_reader(Mode) -> lists:member(read, Mode).
 
 is_writer(Mode) -> lists:member(write, Mode).
@@ -656,14 +660,16 @@ reopen([], Tree, RefHdls) ->
     {ok, lists:reverse(RefHdls)};
 reopen([{Ref, NewOrReopen, Handle = #handle { hdl          = closed,
                                               path         = Path,
-                                              mode         = Mode,
+                                              mode         = Mode0,
                                               offset       = Offset,
                                               last_used_at = undefined }} |
         RefNewOrReopenHdls] = ToOpen, Tree, RefHdls) ->
-    case prim_file:open(Path, case NewOrReopen of
-                                  new    -> Mode;
-                                  reopen -> [read | Mode]
-                              end) of
+    Mode = case NewOrReopen of
+               new    -> Mode0;
+               reopen -> file_handle_cache_stats:update(reopen),
+                         [read | Mode0]
+           end,
+    case prim_file:open(Path, Mode) of
         {ok, Hdl} ->
             Now = now(),
             {{ok, _Offset}, Handle1} =
@@ -838,7 +844,7 @@ maybe_seek(NewOffset, Handle = #handle{hdl              = Hdl,
                 NewOffset < Offset orelse
                 NewOffset > BufSz + Offset of
                 true ->
-                    case prim_file:position(Hdl, NewOffset) of
+                    case prim_file_position(Hdl, NewOffset) of
                         {ok, Offset1} = Result ->
                             {Result, Handle#handle{offset           = Offset1,
                                                    at_eof           = AtEoF1,
diff --git a/src/file_handle_cache_stats.erl b/src/file_handle_cache_stats.erl
index d055d84a..b1fbb3f4 100644
--- a/src/file_handle_cache_stats.erl
+++ b/src/file_handle_cache_stats.erl
@@ -18,7 +18,7 @@
 
 %% stats about read / write operations that go through the fhc.
 
--export([init/0, update/3, update/2, get/0]).
+-export([init/0, update/3, update/2, update/1, get/0]).
 
 -define(TABLE, ?MODULE).
 
@@ -26,8 +26,10 @@ init() ->
     ets:new(?TABLE, [public, named_table]),
     [ets:insert(?TABLE, {{Op, Counter}, 0}) || Op      <- [read, write],
                                                Counter <- [count, bytes, time]],
-    [ets:insert(?TABLE, {{Op, Counter}, 0}) || Op      <- [sync],
-                                               Counter <- [count, time]].
+    [ets:insert(?TABLE, {{Op, Counter}, 0}) || Op      <- [sync, seek],
+                                               Counter <- [count, time]],
+    [ets:insert(?TABLE, {{Op, Counter}, 0}) || Op      <- [reopen],
+                                               Counter <- [count]].
 
 update(Op, Bytes, Thunk) ->
     {Time, Res} = timer:tc(Thunk),
@@ -42,5 +44,9 @@ update(Op, Thunk) ->
     ets:update_counter(?TABLE, {Op, time}, Time),
     Res.
 
+update(Op) ->
+    ets:update_counter(?TABLE, {Op, count}, 1),
+    ok.
+
 get() ->
     lists:sort(ets:tab2list(?TABLE)).
diff --git a/src/rabbit_amqqueue.erl b/src/rabbit_amqqueue.erl
index 68e96742..2e5a5e8c 100644
--- a/src/rabbit_amqqueue.erl
+++ b/src/rabbit_amqqueue.erl
@@ -726,8 +726,10 @@ forget_all_durable(Node) ->
 
 forget_node_for_queue(#amqqueue{name             = Name,
                                 down_slave_nodes = []}) ->
-    %% No slaves to recover from, queue is gone
-    rabbit_binding:process_deletions(internal_delete1(Name, true));
+    %% No slaves to recover from, queue is gone.
+    %% Don't process_deletions since that just calls callbacks and we
+    %% are not really up.
+    internal_delete1(Name, true);
 
 forget_node_for_queue(Q = #amqqueue{down_slave_nodes = [H|T]}) ->
     %% Promote a slave while down - it'll happily recover as a master
diff --git a/src/rabbit_binding.erl b/src/rabbit_binding.erl
index 12d4df99..53af2f20 100644
--- a/src/rabbit_binding.erl
+++ b/src/rabbit_binding.erl
@@ -469,7 +469,10 @@ group_bindings_fold(Fun, SrcName, Acc, Removed, Bindings, OnlyDurable) ->
 
 maybe_auto_delete(XName, Bindings, Deletions, OnlyDurable) ->
     {Entry, Deletions1} =
-        case mnesia:read({rabbit_exchange, XName}) of
+        case mnesia:read({case OnlyDurable of
+                              true  -> rabbit_durable_exchange;
+                              false -> rabbit_exchange
+                          end, XName}) of
             []  -> {{undefined, not_deleted, Bindings}, Deletions};
             [X] -> case rabbit_exchange:maybe_auto_delete(X, OnlyDurable) of
                        not_deleted ->
diff --git a/src/rabbit_diagnostics.erl b/src/rabbit_diagnostics.erl
index 4eafada3..bf45b757 100644
--- a/src/rabbit_diagnostics.erl
+++ b/src/rabbit_diagnostics.erl
@@ -41,13 +41,13 @@ maybe_stuck(Pids, Timeout) ->
     maybe_stuck(Pids2, Timeout - 500).
 
 looks_stuck(Pid) ->
-    case process_info(Pid, status) of
+    case catch process_info(Pid, status) of
         {status, waiting} ->
             %% It's tempting to just check for message_queue_len > 0
             %% here rather than mess around with stack traces and
             %% heuristics. But really, sometimes freshly stuck
             %% processes can have 0 messages...
-            case erlang:process_info(Pid, current_stacktrace) of
+            case catch erlang:process_info(Pid, current_stacktrace) of
                 {current_stacktrace, [H|_]} ->
                     maybe_stuck_stacktrace(H);
                 _ ->