[Easy] LwtInit.run_lwt

Summary:
Previously you needed two calls: one to set the engine and then
one to run the lwt thread. This combines them into a single call.

I originally built this because I was adding a third call. I eventually
didn't add that third call, but still liked this idea better than what I
had before. It also helps that xhpOfReactCommand.ml forgot to set the
engine, which shows that this is useful.

Reviewed By: samwgoldman

Differential Revision: D7272136

fbshipit-source-id: 05c09ee42bc91b8ec169838318104ef2b7146059

Author: gabelevi

src/common/lwt/lwtInit.ml

@@ -108,4 +108,8 @@ let set_engine () =
    * nowhere *)
   if Sys.win32
   then Lwt_engine.set (new windows_select) (* See comment on windows_select *)
-  else Lwt_engine.set (new unix_select); (* See comment on unix_select *)
+  else Lwt_engine.set (new unix_select) (* See comment on unix_select *)
+
+let run_lwt f =
+  set_engine ();
+  Lwt_main.run (f ())

src/common/lwt/lwtInit.mli

@@ -5,4 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  *)
 
-val set_engine: unit -> unit
+val run_lwt: (unit -> 'a Lwt.t) -> 'a

src/monitor/flowServerMonitor.ml

@@ -114,53 +114,53 @@ let internal_start ~is_daemon ?waiting_fd monitor_options =
 
   (************************* HERE BEGINS THE MAGICAL WORLD OF LWT *********************************)
 
-  LwtInit.set_engine ();
-
-  Lwt.async (LogFlusher.run ~cancel_condition:ExitSignal.signal);
-
-  (* If `prom`  in `Lwt.async (fun () -> prom)` resolves to an exception, this function will be
-   * called *)
-  Lwt.async_exception_hook := (fun exn ->
-    let bt = Printexc.get_backtrace () in
-    let msg = Utils.spf "Uncaught async exception: %s%s"
-      (Printexc.to_string exn)
-      (if bt = "" then bt else "\n"^bt)
+  let initial_lwt_thread () =
+    Lwt.async (LogFlusher.run ~cancel_condition:ExitSignal.signal);
+
+    (* If `prom`  in `Lwt.async (fun () -> prom)` resolves to an exception, this function will be
+     * called *)
+    Lwt.async_exception_hook := (fun exn ->
+      let bt = Printexc.get_backtrace () in
+      let msg = Utils.spf "Uncaught async exception: %s%s"
+        (Printexc.to_string exn)
+        (if bt = "" then bt else "\n"^bt)
+      in
+      Logger.fatal ~exn "Uncaught async exception. Exiting";
+      FlowExitStatus.(exit ~msg Unknown_error)
+    );
+
+    Logger.init_logger
+      ?log_fd (Hh_logger.Level.min_level () |> lwt_level_of_hh_logger_level);
+    Logger.info "argv=%s" (argv |> Array.to_list |> String.concat " ");
+
+    (* If there is a waiting fd, start up a thread that will message it *)
+    let handle_waiting_start_command = match waiting_fd with
+    | None -> Lwt.return_unit
+    | Some fd ->
+      let fd = Lwt_unix.of_unix_file_descr ~blocking:true fd in
+      handle_waiting_start_command fd
     in
-    Logger.fatal ~exn "Uncaught async exception. Exiting";
-    FlowExitStatus.(exit ~msg Unknown_error)
-  );
-
-  Logger.init_logger
-    ?log_fd (Hh_logger.Level.min_level () |> lwt_level_of_hh_logger_level);
-  Logger.info "argv=%s" (argv |> Array.to_list |> String.concat " ");
-
-  (* If there is a waiting fd, start up a thread that will message it *)
-  let handle_waiting_start_command = match waiting_fd with
-  | None -> Lwt.return_unit
-  | Some fd ->
-    let fd = Lwt_unix.of_unix_file_descr ~blocking:true fd in
-    handle_waiting_start_command fd
-  in
 
-  (* Don't start the server until we've set up the threads to handle the waiting channel *)
-  Lwt.async (fun () ->
-    let%lwt () = handle_waiting_start_command in
-    FlowServerMonitorServer.start monitor_options
-  );
-
-  (* We can start up the socket acceptor even before the server starts *)
-  Lwt.async (fun () ->
-    SocketAcceptor.run
-      (Lwt_unix.of_unix_file_descr ~blocking:true monitor_socket_fd)
-      monitor_options.FlowServerMonitorOptions.autostop
-  );
-  Lwt.async (fun () ->
-    SocketAcceptor.run_legacy (Lwt_unix.of_unix_file_descr ~blocking:true legacy_socket_fd)
-  );
-
-  (* Wait forever! Mwhahahahahaha *)
-  Lwt.wait () |> fst
-  |> Lwt_main.run
+    (* Don't start the server until we've set up the threads to handle the waiting channel *)
+    Lwt.async (fun () ->
+      let%lwt () = handle_waiting_start_command in
+      FlowServerMonitorServer.start monitor_options
+    );
+
+    (* We can start up the socket acceptor even before the server starts *)
+    Lwt.async (fun () ->
+      SocketAcceptor.run
+        (Lwt_unix.of_unix_file_descr ~blocking:true monitor_socket_fd)
+        monitor_options.FlowServerMonitorOptions.autostop
+    );
+    Lwt.async (fun () ->
+      SocketAcceptor.run_legacy (Lwt_unix.of_unix_file_descr ~blocking:true legacy_socket_fd)
+    );
+
+    (* Wait forever! Mwhahahahahaha *)
+    Lwt.wait () |> fst
+  in
+  LwtInit.run_lwt initial_lwt_thread
 
 let daemon_entry_point =
   FlowServerMonitorDaemon.register_entry_point (internal_start ~is_daemon:true)

src/server/server.ml

@@ -217,8 +217,7 @@ let init_dfind options =
 let create_program_init ~shared_mem_config ~focus_targets options =
   let handle = SharedMem_js.init shared_mem_config in
   let genv = ServerEnvBuild.make_genv options handle in
-  (* Only set up lwt after the workers are created *)
-  LwtInit.set_engine ();
+
   let program_init = fun () ->
     let%lwt profiling, env = init ~focus_targets genv in
     FlowEventLogger.init_done ~profiling;
@@ -233,7 +232,7 @@ let run ~monitor_channels ~shared_mem_config options =
 
   let dfind = init_dfind options in
 
-  let initial_lwt_thread =
+  let initial_lwt_thread () =
     (* Read messages from the server monitor and add them to a stream as they come in *)
     let listening_thread = listen_for_messages () in
 
@@ -250,7 +249,7 @@ let run ~monitor_channels ~shared_mem_config options =
       serve ~dfind ~genv ~env
     ]
   in
-  Lwt_main.run initial_lwt_thread
+  LwtInit.run_lwt initial_lwt_thread
 
 let run_from_daemonize ~monitor_channels ~shared_mem_config options =
   try run ~monitor_channels ~shared_mem_config options
@@ -269,7 +268,7 @@ let check_once ~shared_mem_config ~client_include_warnings ?focus_targets option
   PidLog.disable ();
   MonitorRPC.disable ();
 
-  let initial_lwt_thread =
+  let initial_lwt_thread () =
     let _, program_init =
       create_program_init ~shared_mem_config ~focus_targets options in
     let%lwt profiling, env = program_init () in
@@ -281,7 +280,7 @@ let check_once ~shared_mem_config ~client_include_warnings ?focus_targets option
     in
     Lwt.return (profiling, errors, warnings, suppressed_errors)
   in
-  Lwt_main.run initial_lwt_thread
+  LwtInit.run_lwt initial_lwt_thread
 
 let daemonize =
   let entry = Server_daemon.register_entry_point run_from_daemonize in