Merge pull request #10235 from The-OpenROAD-Project-staging/feature-Web-GUI

Feature Web GUI

Author: maliberty

src/CMakeLists.txt

@@ -345,7 +345,6 @@ target_link_libraries(openroad
   cut
   grt
   tap
-  gui
   drt
   dst
   psm
@@ -358,6 +357,7 @@ target_link_libraries(openroad
   par
   est
   web
+  gui
   absl::synchronization
   ${ABC_LIBRARY}
   ${TCL_LIBRARY}

src/web/include/web/web.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <spdlog/common.h>
+
 #include <condition_variable>
 #include <cstdint>
 #include <functional>
@@ -108,29 +110,37 @@ class WebServer
                  double dbu_per_pixel,
                  const std::string& vis_json);
 
- private:
-  // Tears down the I/O threads and cleans up hooks.  Called by the
-  // destructor; safe to call multiple times.
+  // Tears down the I/O threads and cleans up hooks.  Safe to call multiple
+  // times and from any thread; after it returns, isRunning() is false and
+  // serve() may be called again to restart the server.
   void stop();
 
+ private:
+  // Stops ioc_, joins every worker thread except the current one, and
+  // clears threads_. Detaches the current thread if it happens to be a
+  // worker (would otherwise raise EDEADLK on self-join).
+  void stopAndJoinIoThreads();
+
   odb::dbDatabase* db_ = nullptr;
   sta::dbSta* sta_ = nullptr;
   utl::Logger* logger_ = nullptr;
   Tcl_Interp* interp_ = nullptr;
   int num_threads_ = 0;
   std::shared_ptr<TileGenerator> generator_;
   std::unique_ptr<WebViewerHook> viewer_hook_;
-  std::shared_ptr<spdlog::sinks::sink> log_sink_;
 
   // Background I/O context and worker threads (non-null while running).
   std::unique_ptr<boost::asio::io_context> ioc_;
   std::vector<std::thread> threads_;
 
-  // Type-erased callback that closes the Listener's acceptor before the
-  // io_context is destroyed — prevents a crash where the acceptor's
-  // destructor references the io_context that's mid-destruction.
+  // Closes the Listener's acceptor before the io_context is destroyed,
+  // avoiding a crash where the acceptor references a half-destroyed
+  // io_context.
   std::function<void()> shutdown_listener_;
 
+  // Held so stop() can remove it from the Logger before viewer_hook_ is
+  // destroyed — the sink stores a raw pointer into the hook.
+  spdlog::sink_ptr log_sink_;
   // Blocking support: waitForStop() sleeps on stop_cv_ until
   // requestStop() sets stop_requested_.
   std::mutex stop_mutex_;

src/web/src/main.js

@@ -361,6 +361,42 @@ function tclAppend(text, className) {
     app.tclOutputEl.scrollTop = app.tclOutputEl.scrollHeight;
 }
 
+// Browser UX for `exit`/`quit` typed in the Tcl console. The browser
+// override (web_serve.cpp tclExitHandler) sets exit_requested_, and
+// Main.cc calls exit(EXIT_SUCCESS) once waitForStop() returns — so the
+// whole OpenROAD process exits, not just the web session. (Compare
+// `web_server -stop`, which only stops serving and arrives here as a
+// broadcast `type: shutdown` handled below.)
+// window.close() only succeeds when the tab was opened via JS (or via
+// certain launcher integrations); when it fails we replace the page
+// with a terminal overlay so the user knows OpenROAD exited and they
+// can close the tab manually.
+function handleServerShutdown() {
+    // Idempotent: invoked from both the Tcl-eval response (`action: shutdown`)
+    // and the broadcast push (`type: shutdown`); whichever arrives first wins.
+    if (app._shutdownHandled) return;
+    app._shutdownHandled = true;
+    // Disable auto-reconnect and suppress the "disconnected" banner —
+    // the disconnect is intentional.
+    if (app.websocketManager) {
+        app.websocketManager._shutdown = true;
+        app.websocketManager.onPush = () => {};
+    }
+    const overlay = document.createElement('div');
+    overlay.style.cssText =
+        'position:fixed;inset:0;z-index:99999;background:#1e1e1e;color:#ddd;' +
+        'display:flex;flex-direction:column;align-items:center;justify-content:center;' +
+        'font-family:system-ui,sans-serif;font-size:16px;padding:24px;text-align:center;';
+    overlay.innerHTML =
+        '<div style="font-size:22px;margin-bottom:12px;">OpenROAD exited</div>' +
+        '<div style="opacity:0.7;">You can close this tab.</div>';
+    document.body.appendChild(overlay);
+    // Hold the overlay visible long enough for the user to read it before
+    // window.close() fires.  400 ms was below the perceptual threshold and
+    // looked like the tab vanished instantly on `exit`.
+    setTimeout(() => { try { window.close(); } catch (e) { /* ignore */ } }, 1500);
+}
+
 function createTclConsole(container) {
     const el = document.createElement('div');
     el.className = 'tcl-console';
@@ -396,6 +432,9 @@ function createTclConsole(container) {
                         tclAppend(data.result + '\n',
                                   data.is_error ? 'tcl-error' : '');
                     }
+                    if (data.action === 'shutdown') {
+                        handleServerShutdown();
+                    }
                 })
                 .catch(err => tclAppend(`Error: ${err}\n`, 'tcl-error'));
         }
@@ -730,7 +769,11 @@ app.websocketManager.onPush = (msg) => {
         if (text) tclAppend(text + '\n', '');
     } else if (msg.type === 'shutdown') {
         // Server is stopping intentionally (web_server -stop).
-        // Disable auto-reconnect and show a clear message.
+        // Disable auto-reconnect and show a clear message. Note that
+        // when the user typed `exit`/`quit` in the browser, the eval
+        // response's `action: shutdown` already ran handleServerShutdown
+        // (which set _shutdown and replaced onPush with a no-op), so
+        // this branch only runs in the external-stop case.
         app.websocketManager._shutdown = true;
         statusDiv.innerHTML = '<div class="disconnected-banner">Server stopped</div>';
         statusDiv.style.display = 'block';

src/web/src/request_handler.cpp

@@ -37,6 +37,7 @@
 #include "request_dispatcher.h"
 #include "tile_generator.h"
 #include "timing_report.h"
+#include "utl/Logger.h"
 
 namespace web {
 
@@ -1418,12 +1419,27 @@ WebSocketResponse TclHandler::handleTclEval(const WebSocketRequest& req)
   resp.id = req.id;
   resp.type = WebSocketResponse::kJson;
   try {
-    auto result = tcl_eval_->eval(extract_string(req.raw_json, "cmd"));
+    const std::string cmd = extract_string(req.raw_json, "cmd");
+    auto result = tcl_eval_->eval(cmd);
+    // tclExitHandler (web_serve.cpp) sets this sentinel as the Tcl
+    // result whenever `exit`/`quit` is evaluated through the override —
+    // whether typed bare in the browser or buried in `eval`/`source`.
+    // Convert it to a clean shutdown signal for the browser; the actual
+    // teardown is already requested by tclExitHandler via requestStop().
+    const bool is_exit = (result.result == kExitResultMsg);
     JsonBuilder builder;
     builder.beginObject();
     builder.field("output", result.output);
-    builder.field("result", result.result);
-    builder.field("is_error", result.is_error);
+    if (is_exit) {
+      tcl_eval_->logger->info(
+          utl::WEB, 40, "Exit requested from web GUI; shutting down.");
+      builder.field("result", "Exiting OpenROAD.");
+      builder.field("is_error", false);
+      builder.field("action", "shutdown");
+    } else {
+      builder.field("result", result.result);
+      builder.field("is_error", result.is_error);
+    }
     builder.endObject();
     const std::string& json = builder.str();
     resp.payload.assign(json.begin(), json.end());

src/web/src/request_handler.h

@@ -26,6 +26,12 @@ class RequestDispatcher;
 class TimingReport;
 class ClockTreeReport;
 
+// Sentinel string set as the Tcl result by WebServer::tclExitHandler
+// when the browser-side Tcl `exit`/`quit` is invoked.  TclHandler
+// detects this in handleTclEval and converts the response to a clean
+// shutdown signal for the browser.
+inline constexpr const char* kExitResultMsg = "_WEB_EXITING_";
+
 // Thread-safe Tcl command evaluation with output capture.
 struct TclEvaluator
 {

src/web/src/web.cpp

@@ -813,6 +813,31 @@ WebServer::WebServer(odb::dbDatabase* db,
 {
 }
 
+// Defined here (not in web_serve.cpp) so the destructor's TU does not
+// pull in web_serve.cpp's gui::Gui::get() references — keeps WebServer
+// usable from tests that don't link the full gui library.
+void WebServer::stopAndJoinIoThreads()
+{
+  if (ioc_) {
+    ioc_->stop();
+  }
+  const auto self_id = std::this_thread::get_id();
+  for (auto& t : threads_) {
+    if (!t.joinable()) {
+      continue;
+    }
+    if (t.get_id() == self_id) {
+      // Self-join would raise EDEADLK. ioc_->stop() above unblocks the
+      // worker so detaching is safe — the thread runs to completion on
+      // its own.
+      t.detach();
+    } else {
+      t.join();
+    }
+  }
+  threads_.clear();
+}
+
 WebServer::~WebServer()
 {
   // Wake any thread blocked in waitForStop() so it can return before
@@ -825,24 +850,12 @@ WebServer::~WebServer()
 
   // The destructor fires during Tcl_Exit → atexit → ~OpenRoad chain.
   // By this point the Tcl interpreter is partially torn down and static
-  // objects may be destroyed.  Calling stop() (which joins 32 threads
-  // and tears down boost::asio's reactor) triggers SIGSEGV because the
-  // reactor's internal state references destroyed statics.
-  //
-  // Since the destructor only runs at process exit, the OS reclaims all
-  // memory and closes all sockets.  We just need to stop the threads so
-  // the process can actually exit:
-  if (ioc_) {
-    ioc_->stop();
-  }
-  for (auto& t : threads_) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-  threads_.clear();
-  // Close the Listener's acceptor and release the shared_ptr to it
-  // before the io_context goes away.
+  // objects may be destroyed.  We avoid the full stop() path (which
+  // tears down boost::asio's reactor and would crash on residual async
+  // handlers referencing destroyed statics) — the OS reclaims memory
+  // and sockets at process exit, so we only need to release the worker
+  // threads so the process can actually exit.
+  stopAndJoinIoThreads();
   if (shutdown_listener_) {
     shutdown_listener_();
     shutdown_listener_ = {};

src/web/src/web_serve.cpp

@@ -48,7 +48,6 @@ using Tcp = net::ip::tcp;
 // Tcl command name used to stash the original `exit` while our override
 // is installed.  Mirrors gui::TclCmdInputWidget's kCommandRenamePrefix.
 static constexpr const char* kRenamedExitCmd = "::tcl::openroad::web_orig_exit";
-static constexpr const char* kExitResultMsg = "_WEB_EXITING_";
 
 // Logger sink that accumulates lines and sends them as a batch to
 // connected browser clients.  Flushing is explicit (via drainToClients)
@@ -141,6 +140,8 @@ void WebServer::serve(int port)
     // ~WebServer's self-join → std::terminate).  Same pattern as
     // gui::TclCmdInputWidget.  The handler signals waitForStop() and
     // sets exit_requested_; the main thread does the real exit.
+    // TclHandler::handleTclEval detects kExitResultMsg in the Tcl
+    // result and sends `action: "shutdown"` to the browser.
     exit_requested_ = false;
     {
       const std::string rename_orig
@@ -216,7 +217,15 @@ void WebServer::serve(int port)
 #elif defined(_WIN32)
     std::string open_cmd = "start " + url + " > nul 2>&1";
 #else
-    std::string open_cmd = "xdg-open " + url + " > /dev/null 2>&1 &";
+    // `setsid -f` forks the launcher into a new session, severing the
+    // SIGHUP cascade from openroad's controlling pty.  Without this,
+    // running openroad from inside an emacs shell-mode buffer kills
+    // the browser tab as soon as openroad exits, because emacs holds
+    // the pty master and SIGHUPs every process in the session.  Also
+    // redirect stdin from /dev/null so xdg-open never blocks on input
+    // inherited from the pty.
+    std::string open_cmd
+        = "setsid -f xdg-open " + url + " < /dev/null > /dev/null 2>&1";
 #endif
     int ret = std::system(open_cmd.c_str());
     (void) ret;
@@ -304,18 +313,21 @@ void WebServer::stop()
     shutdown_listener_();
     shutdown_listener_ = {};
   }
-  if (ioc_) {
-    ioc_->stop();
-  }
-  for (auto& t : threads_) {
-    if (t.joinable()) {
-      t.join();
-    }
-  }
-  threads_.clear();
+  stopAndJoinIoThreads();
+  // Release without destroying — destroying io_context can crash on
+  // residual async handlers. Leak is bounded (at most one io_context
+  // per serve/stop cycle).
   (void) ioc_.release();  // NOLINT(bugprone-unused-return-value)
   generator_.reset();
+  // Remove the log sink before destroying viewer_hook_ — the sink
+  // stores a raw pointer into it and the CLI thread may emit a log
+  // line at any moment.
+  if (log_sink_) {
+    logger_->removeSink(log_sink_);
+    log_sink_.reset();
+  }
   viewer_hook_.reset();
+  logger_->info(utl::WEB, 41, "Web session closed.");
 }
 
 }  // namespace web