use file2 in most cases in queue_index, file_handle_cache and misc

Unfortunately, the worker pool is now a pre-requisite for some file
operations, so we have to start it in prelaunch:start/0 and rabbit:prepare/0.

5 files changed, 40 insertions, 34 deletions

diff --git a/src/file_handle_cache.erl b/src/file_handle_cache.erl
index 3c2111dc78..39be0e9b56 100644
--- a/src/file_handle_cache.erl
+++ b/src/file_handle_cache.erl
@@ -317,7 +317,7 @@ read(Ref, Count) ->
       fun ([#handle { is_read = false }]) ->
               {error, not_open_for_reading};
           ([Handle = #handle { hdl = Hdl, offset = Offset }]) ->
-              case file:read(Hdl, Count) of
+              case file2:read(Hdl, Count) of
                   {ok, Data} = Obj -> Offset1 = Offset + iolist_size(Data),
                                       {Obj,
                                        [Handle #handle { offset = Offset1 }]};
@@ -337,7 +337,7 @@ append(Ref, Data) ->
                                             write_buffer_size_limit = 0,
                                             at_eof = true } = Handle1} ->
                       Offset1 = Offset + iolist_size(Data),
-                      {file:write(Hdl, Data),
+                      {file2:write(Hdl, Data),
                        [Handle1 #handle { is_dirty = true, offset = Offset1 }]};
                   {{ok, _Offset}, #handle { write_buffer = WriteBuffer,
                                             write_buffer_size = Size,
@@ -364,7 +364,7 @@ sync(Ref) ->
               ok;
           ([Handle = #handle { hdl = Hdl,
                                is_dirty = true, write_buffer = [] }]) ->
-              case file:sync(Hdl) of
+              case file2:sync(Hdl) of
                   ok    -> {ok, [Handle #handle { is_dirty = false }]};
                   Error -> {Error, [Handle]}
               end
@@ -381,7 +381,7 @@ truncate(Ref) ->
     with_flushed_handles(
       [Ref],
       fun ([Handle1 = #handle { hdl = Hdl }]) ->
-              case file:truncate(Hdl) of
+              case file2:truncate(Hdl) of
                   ok    -> {ok, [Handle1 #handle { at_eof = true }]};
                   Error -> {Error, [Handle1]}
               end
@@ -408,7 +408,7 @@ copy(Src, Dest, Count) ->
       fun ([SHandle = #handle { is_read  = true, hdl = SHdl, offset = SOffset },
             DHandle = #handle { is_write = true, hdl = DHdl, offset = DOffset }]
           ) ->
-              case file:copy(SHdl, DHdl, Count) of
+              case file2:copy(SHdl, DHdl, Count) of
                   {ok, Count1} = Result1 ->
                       {Result1,
                        [SHandle #handle { offset = SOffset + Count1 },
@@ -428,7 +428,7 @@ delete(Ref) ->
         Handle = #handle { path = Path } ->
             case hard_close(Handle #handle { is_dirty = false,
                                              write_buffer = [] }) of
-                ok               -> file:delete(Path);
+                ok               -> file2:delete(Path);
                 {Error, Handle1} -> put_handle(Ref, Handle1),
                                     Error
             end
@@ -443,7 +443,7 @@ clear(Ref) ->
               case maybe_seek(bof, Handle #handle { write_buffer = [],
                                                     write_buffer_size = 0 }) of
                   {{ok, 0}, Handle1 = #handle { hdl = Hdl }} ->
-                      case file:truncate(Hdl) of
+                      case file2:truncate(Hdl) of
                           ok    -> {ok, [Handle1 #handle { at_eof = true }]};
                           Error -> {Error, [Handle1]}
                       end;
@@ -566,7 +566,7 @@ reopen([{Ref, NewOrReopen, Handle = #handle { hdl          = closed,
                                               offset       = Offset,
                                               last_used_at = undefined }} |
         RefNewOrReopenHdls] = ToOpen, Tree, RefHdls) ->
-    case file:open(Path, case NewOrReopen of
+    case file2:open(Path, case NewOrReopen of
                              new    -> Mode;
                              reopen -> [read | Mode]
                          end) of
@@ -693,10 +693,10 @@ soft_close(Handle) ->
                        is_dirty    = IsDirty,
                        last_used_at = Then } = Handle1 } ->
             ok = case IsDirty of
-                     true  -> file:sync(Hdl);
+                     true  -> file2:sync(Hdl);
                      false -> ok
                  end,
-            ok = file:close(Hdl),
+            ok = file2:close(Hdl),
             age_tree_delete(Then),
             {ok, Handle1 #handle { hdl            = closed,
                                    is_dirty       = false,
@@ -731,7 +731,7 @@ maybe_seek(NewOffset, Handle = #handle { hdl = Hdl, offset = Offset,
                                          at_eof = AtEoF }) ->
     {AtEoF1, NeedsSeek} = needs_seek(AtEoF, Offset, NewOffset),
     case (case NeedsSeek of
-              true  -> file:position(Hdl, NewOffset);
+              true  -> file2:position(Hdl, NewOffset);
               false -> {ok, Offset}
           end) of
         {ok, Offset1} = Result ->
@@ -768,7 +768,7 @@ write_buffer(Handle = #handle { hdl = Hdl, offset = Offset,
                                 write_buffer = WriteBuffer,
                                 write_buffer_size = DataSize,
                                 at_eof = true }) ->
-    case file:write(Hdl, lists:reverse(WriteBuffer)) of
+    case file2:write(Hdl, lists:reverse(WriteBuffer)) of
         ok ->
             Offset1 = Offset + DataSize,
             {ok, Handle #handle { offset = Offset1, is_dirty = true,
diff --git a/src/rabbit.erl b/src/rabbit.erl
index b8dbccc767..0a4aa03240 100644
--- a/src/rabbit.erl
+++ b/src/rabbit.erl
@@ -211,8 +211,11 @@
 %%----------------------------------------------------------------------------
 
 prepare() ->
+    %% Some of the rabbit_misc functions use worker_pool, so start it now.
+    {ok, Pid} = worker_pool_sup:start_link(),
     ok = ensure_working_log_handlers(),
-    ok = rabbit_upgrade:maybe_upgrade_mnesia().
+    ok = rabbit_upgrade:maybe_upgrade_mnesia(),
+    exit(Pid, shutdown).
 
 start() ->
     try
diff --git a/src/rabbit_misc.erl b/src/rabbit_misc.erl
index ae28722ab2..e8542574a7 100644
--- a/src/rabbit_misc.erl
+++ b/src/rabbit_misc.erl
@@ -526,7 +526,7 @@ dirty_dump_log1(LH, {K, Terms, BadBytes}) ->
     dirty_dump_log1(LH, disk_log:chunk(LH, K)).
 
 
-read_term_file(File) -> file:consult(File).
+read_term_file(File) -> file2:consult(File).
 
 write_term_file(File, Terms) ->
     write_file(File, list_to_binary([io_lib:format("~w.~n", [Term]) ||
@@ -544,12 +544,12 @@ write_file(Path, Data, Modes) ->
     Modes1 = [binary, write | (Modes -- [binary, write])],
     case make_binary(Data) of
         Bin when is_binary(Bin) ->
-            case file:open(Path, Modes1) of
-                {ok, Hdl}      -> try file:write(Hdl, Bin) of
-                                      ok             -> file:sync(Hdl);
+            case file2:open(Path, Modes1) of
+                {ok, Hdl}      -> try file2:write(Hdl, Bin) of
+                                      ok             -> file2:sync(Hdl);
                                       {error, _} = E -> E
                                   after
-                                      file:close(Hdl)
+                                      file2:close(Hdl)
                                   end;
                 {error, _} = E -> E
             end;
@@ -567,7 +567,7 @@ make_binary(List) ->
 
 
 append_file(File, Suffix) ->
-    case file:read_file_info(File) of
+    case file2:read_file_info(File) of
         {ok, FInfo}     -> append_file(File, FInfo#file_info.size, Suffix);
         {error, enoent} -> append_file(File, 0, Suffix);
         Error           -> Error
@@ -576,12 +576,12 @@ append_file(File, Suffix) ->
 append_file(_, _, "") ->
     ok;
 append_file(File, 0, Suffix) ->
-    case file:open([File, Suffix], [append]) of
-        {ok, Fd} -> file:close(Fd);
+    case file2:open([File, Suffix], [append]) of
+        {ok, Fd} -> file2:close(Fd);
         Error    -> Error
     end;
 append_file(File, _, Suffix) ->
-    case file:read_file(File) of
+    case file2:read_file(File) of
         {ok, Data} -> write_file([File, Suffix], Data, [append]);
         Error      -> Error
     end.
@@ -750,12 +750,12 @@ recursive_delete(Files) ->
 
 recursive_delete1(Path) ->
     case filelib:is_dir(Path) of
-        false -> case file:delete(Path) of
+        false -> case file2:delete(Path) of
                      ok              -> ok;
                      {error, enoent} -> ok; %% Path doesn't exist anyway
                      {error, Err}    -> {error, {Path, Err}}
                  end;
-        true  -> case file:list_dir(Path) of
+        true  -> case file2:list_dir(Path) of
                      {ok, FileNames} ->
                          case lists:foldl(
                                 fun (FileName, ok) ->
@@ -765,7 +765,7 @@ recursive_delete1(Path) ->
                                         Error
                                 end, ok, FileNames) of
                              ok ->
-                                 case file:del_dir(Path) of
+                                 case file2:del_dir(Path) of
                                      ok           -> ok;
                                      {error, Err} -> {error, {Path, Err}}
                                  end;
@@ -779,14 +779,14 @@ recursive_delete1(Path) ->
 
 recursive_copy(Src, Dest) ->
     case filelib:is_dir(Src) of
-        false -> case file:copy(Src, Dest) of
+        false -> case file2:copy(Src, Dest) of
                      {ok, _Bytes}    -> ok;
                      {error, enoent} -> ok; %% Path doesn't exist anyway
                      {error, Err}    -> {error, {Src, Dest, Err}}
                  end;
-        true  -> case file:list_dir(Src) of
+        true  -> case file2:list_dir(Src) of
                      {ok, FileNames} ->
-                         case file:make_dir(Dest) of
+                         case file2:make_dir(Dest) of
                              ok ->
                                  lists:foldl(
                                    fun (FileName, ok) ->
@@ -898,8 +898,8 @@ build_acyclic_graph(VertexFun, EdgeFun, Graph) ->
 lock_file(Path) ->
     case filelib:is_file(Path) of
         true  -> {error, eexist};
-        false -> {ok, Lock} = file:open(Path, [write]),
-                 ok = file:close(Lock)
+        false -> {ok, Lock} = file2:open(Path, [write]),
+                 ok = file2:close(Lock)
     end.
 
 const_ok() -> ok.
diff --git a/src/rabbit_prelaunch.erl b/src/rabbit_prelaunch.erl
index 92829e4918..35ffba0fe3 100644
--- a/src/rabbit_prelaunch.erl
+++ b/src/rabbit_prelaunch.erl
@@ -37,6 +37,9 @@
 start() ->
     io:format("Activating RabbitMQ plugins ...~n"),
 
+    %% Some of the rabbit_misc functions use worker_pool.
+    worker_pool_sup:start_link(),
+
     %% Determine our various directories
     [PluginDir, UnpackedPluginDir, NodeStr] = init:get_plain_arguments(),
     RootName = UnpackedPluginDir ++ "/rabbit",
diff --git a/src/rabbit_queue_index.erl b/src/rabbit_queue_index.erl
index 636913b5c8..d7ed270970 100644
--- a/src/rabbit_queue_index.erl
+++ b/src/rabbit_queue_index.erl
@@ -366,7 +366,7 @@ recover(DurableQueues) ->
     {DurableTerms, {fun queue_index_walker/1, {start, DurableQueueNames}}}.
 
 all_queue_directory_names(Dir) ->
-    case file:list_dir(Dir) of
+    case file2:list_dir(Dir) of
         {ok, Entries}   -> [ Entry || Entry <- Entries,
                                       filelib:is_dir(
                                         filename:join(Dir, Entry)) ];
@@ -392,7 +392,7 @@ blank_state(QueueName) ->
 clean_file_name(Dir) -> filename:join(Dir, ?CLEAN_FILENAME).
 
 detect_clean_shutdown(Dir) ->
-    case file:delete(clean_file_name(Dir)) of
+    case file2:delete(clean_file_name(Dir)) of
         ok              -> true;
         {error, enoent} -> false
     end.
@@ -604,7 +604,7 @@ flush_journal(State = #qistate { segments = Segments }) ->
         segment_fold(
           fun (#segment { unacked = 0, path = Path }, SegmentsN) ->
                   case filelib:is_file(Path) of
-                      true  -> ok = file:delete(Path);
+                      true  -> ok = file2:delete(Path);
                       false -> ok
                   end,
                   SegmentsN;
@@ -1059,7 +1059,7 @@ transform_file(Path, Fun) ->
                 ok = drive_transform_fun(Fun, PathTmpHdl, Content),
 
                 ok = file_handle_cache:close(PathTmpHdl),
-                ok = file:rename(PathTmp, Path)
+                ok = file2:rename(PathTmp, Path)
     end.
 
 drive_transform_fun(Fun, Hdl, Contents) ->