Make use of the new serve_web_viewer function

crates/top/re_sdk/src/lib.rs

@@ -34,7 +34,7 @@ pub use self::recording_stream::{
 };
 
 /// The default port of a Rerun gRPC server.
-pub const DEFAULT_SERVER_PORT: u16 = 9876;
+pub const DEFAULT_SERVER_PORT: u16 = re_uri::DEFAULT_PROXY_PORT;
 
 /// The default URL of a Rerun gRPC server.
 ///

crates/top/re_sdk/src/recording_stream.rs

@@ -619,7 +619,10 @@ impl RecordingStreamBuilder {
     //
     // # TODO(#5531): keep static data around.
     #[cfg(feature = "web_viewer")]
-    #[deprecated(since = "0.20.0", note = "use serve_web() instead")]
+    #[deprecated(
+        since = "0.20.0",
+        note = "use rec.serve_grpc() with rerun::serve_web_viewer() instead"
+    )]
     pub fn serve(
         self,
         bind_ip: &str,
@@ -653,6 +656,8 @@ impl RecordingStreamBuilder {
     /// You can limit the amount of data buffered by the gRPC server with the `server_memory_limit` argument.
     /// Once reached, the earliest logged data will be dropped. Static data is never dropped.
     ///
+    /// Calling `serve_web` is equivalent to calling [`Self::serve_grpc`] followed by [`crate::serve_web_viewer`].
+    ///
     /// ## Example
     ///
     /// ```ignore

crates/top/rerun/src/clap.rs

@@ -131,14 +131,15 @@ impl RerunArgs {
                 let server_memory_limit = re_memory::MemoryLimit::parse(&self.server_memory_limit)
                     .map_err(|err| anyhow::format_err!("Bad --server-memory-limit: {err}"))?;
 
-                let open_browser = true;
-                let rec = RecordingStreamBuilder::new(application_id).serve_web(
-                    &self.bind,
-                    Default::default(),
-                    Default::default(),
-                    server_memory_limit,
-                    open_browser,
-                )?;
+                let rec = RecordingStreamBuilder::new("rerun_example_minimal_serve")
+                    .serve_grpc_opts(&self.bind, crate::DEFAULT_SERVER_PORT, server_memory_limit)?;
+
+                crate::serve_web_viewer(crate::web_viewer::WebViewerConfig {
+                    open_browser: true,
+                    connect_to: Some("rerun+http://localhost:9876/proxy".to_owned()),
+                    ..Default::default()
+                })?
+                .detach();
 
                 // Ensure the server stays alive until the end of the program.
                 let sleep_guard = ServeGuard {

crates/utils/re_uri/src/lib.rs

@@ -54,3 +54,6 @@ pub use self::{
 pub mod external {
     pub use url;
 }
+
+/// The default port of a Rerun gRPC proxy server .
+pub const DEFAULT_PROXY_PORT: u16 = 9876;

crates/utils/re_uri/src/origin.rs

@@ -48,25 +48,49 @@ impl Origin {
 
     /// Parses a URL and returns the [`crate::Origin`] and the canonical URL (i.e. one that
     ///  starts with `http://` or `https://`).
-    pub(crate) fn replace_and_parse(value: &str) -> Result<(Self, url::Url), Error> {
-        let scheme: Scheme = value.parse()?;
-        let rewritten = scheme.canonical_url(value);
+    pub(crate) fn replace_and_parse(input: &str) -> Result<(Self, url::Url), Error> {
+        let scheme: Scheme;
+        let rewritten;
+
+        if !input.contains("://") && (input.contains("localhost") || input.contains("127.0.0.1")) {
+            // Assume `rerun+http://`, because that is the default for localhost
+            scheme = Scheme::RerunHttp;
+            rewritten = format!("http://{input}");
+        } else {
+            scheme = input.parse()?;
+            rewritten = scheme.canonical_url(input);
+        }
 
         // We have to first rewrite the endpoint, because `Url` does not allow
         // `.set_scheme()` for non-opaque origins, nor does it return a proper
         // `Origin` in that case.
         let mut http_url = url::Url::parse(&rewritten)?;
 
-        // If we parse a Url from e.g. `https://redap.rerun.io:443`, `port` in the Url struct will
-        // be `None`. So we need to use `port_or_known_default` to get the port back.
-        // See also: https://github.com/servo/rust-url/issues/957
-        if http_url.port_or_known_default().is_none() {
-            // If no port is specified, we assume the default redap port:
-            http_url.set_port(Some(51234)).ok();
+        let mut has_port = true;
+        {
+            // Parsing with a non-standard scheme
+            // is a hack to work around the `url` crate bug
+            // <https://github.com/servo/rust-url/issues/957>.
+            if let Some(rest) = http_url.to_string().strip_prefix("http://") {
+                has_port = url::Url::parse(&format!("foobarbaz://{rest}"))?
+                    .port()
+                    .is_some();
+            } else if let Some(rest) = http_url.to_string().strip_prefix("https://") {
+                has_port = url::Url::parse(&format!("foobarbaz://{rest}"))?
+                    .port()
+                    .is_some();
+            } else {
+                // Should not happen.
+            };
+        }
+
+        if !has_port {
+            // If no port is specified, we assume the default:
+            http_url.set_port(Some(crate::DEFAULT_PROXY_PORT)).ok();
         }
 
         let url::Origin::Tuple(_, host, port) = http_url.origin() else {
-            return Err(Error::UnexpectedOpaqueOrigin(value.to_owned()));
+            return Err(Error::UnexpectedOpaqueOrigin(input.to_owned()));
         };
 
         let origin = Self { scheme, host, port };

crates/utils/re_uri/src/redap_uri.rs

@@ -362,7 +362,7 @@ mod tests {
 
     #[test]
     fn test_localhost_url() {
-        let url = "rerun+http://localhost:51234/catalog";
+        let url = "rerun+http://localhost:9876/catalog";
         let address: RedapUri = url.parse().unwrap();
 
         assert_eq!(
@@ -371,7 +371,7 @@ mod tests {
                 origin: Origin {
                     scheme: Scheme::RerunHttp,
                     host: url::Host::<String>::Domain("localhost".to_owned()),
-                    port: 51234
+                    port: 9876
                 }
             })
         );
@@ -390,7 +390,7 @@ mod tests {
 
     #[test]
     fn test_invalid_path() {
-        let url = "rerun://0.0.0.0:51234/redap/recordings/12345";
+        let url = "rerun://0.0.0.0:9876/redap/recordings/12345";
         let address: Result<RedapUri, _> = url.parse();
 
         assert!(matches!(
@@ -401,65 +401,101 @@ mod tests {
 
     #[test]
     fn test_proxy_endpoint() {
-        let url = "rerun://localhost:51234/proxy";
+        let url = "rerun://localhost:9876/proxy";
         let address: Result<RedapUri, _> = url.parse();
 
         let expected = RedapUri::Proxy(ProxyUri {
             origin: Origin {
                 scheme: Scheme::Rerun,
                 host: url::Host::Domain("localhost".to_owned()),
-                port: 51234,
+                port: 9876,
             },
         });
 
         assert_eq!(address.unwrap(), expected);
 
-        let url = "rerun://localhost:51234/proxy/";
+        let url = "rerun://localhost:9876/proxy/";
         let address: Result<RedapUri, _> = url.parse();
 
         assert_eq!(address.unwrap(), expected);
     }
 
     #[test]
     fn test_catalog_default() {
-        let url = "rerun://localhost:51234";
+        let url = "rerun://localhost:9876";
         let address: Result<RedapUri, _> = url.parse();
 
         let expected = RedapUri::Catalog(CatalogUri {
             origin: Origin {
                 scheme: Scheme::Rerun,
                 host: url::Host::Domain("localhost".to_owned()),
-                port: 51234,
+                port: 9876,
             },
         });
 
         assert_eq!(address.unwrap(), expected);
 
-        let url = "rerun://localhost:51234/";
+        let url = "rerun://localhost:9876/";
         let address: Result<RedapUri, _> = url.parse();
 
         assert_eq!(address.unwrap(), expected);
     }
 
     #[test]
-    #[ignore]
-    // TODO(lucasmerlin): This should ideally work but doesn't right now because of a issue in the `url` crate:
-    // https://github.com/servo/rust-url/issues/957
-    // See also `replace_and_parse` in `origin.rs`
     fn test_default_port() {
         let url = "rerun://localhost";
 
         let expected = RedapUri::Catalog(CatalogUri {
             origin: Origin {
                 scheme: Scheme::Rerun,
                 host: url::Host::Domain("localhost".to_owned()),
-                port: 51234,
+                port: 9876,
             },
         });
 
         assert_eq!(url.parse::<RedapUri>().unwrap(), expected);
     }
 
+    #[test]
+    fn test_default_everything() {
+        let test_cases = [
+            (
+                "localhost",
+                RedapUri::Catalog(CatalogUri {
+                    origin: Origin {
+                        scheme: Scheme::RerunHttp,
+                        host: url::Host::Domain("localhost".to_owned()),
+                        port: 9876,
+                    },
+                }),
+            ),
+            (
+                "localhost/proxy",
+                RedapUri::Proxy(ProxyUri {
+                    origin: Origin {
+                        scheme: Scheme::RerunHttp,
+                        host: url::Host::Domain("localhost".to_owned()),
+                        port: 9876,
+                    },
+                }),
+            ),
+            (
+                "127.0.0.1/proxy",
+                RedapUri::Proxy(ProxyUri {
+                    origin: Origin {
+                        scheme: Scheme::RerunHttp,
+                        host: url::Host::Ipv4(Ipv4Addr::new(127, 0, 0, 1)),
+                        port: 9876,
+                    },
+                }),
+            ),
+        ];
+
+        for (url, expected) in test_cases {
+            assert_eq!(url.parse::<RedapUri>().unwrap(), expected);
+        }
+    }
+
     #[test]
     fn test_custom_port() {
         let url = "rerun://localhost:123";
@@ -474,4 +510,34 @@ mod tests {
 
         assert_eq!(url.parse::<RedapUri>().unwrap(), expected);
     }
+
+    #[test]
+    fn test_default_localhost_scheme() {
+        let test_cases = [
+            (
+                "localhost:123",
+                RedapUri::Catalog(CatalogUri {
+                    origin: Origin {
+                        scheme: Scheme::RerunHttp,
+                        host: url::Host::Domain("localhost".to_owned()),
+                        port: 123,
+                    },
+                }),
+            ),
+            (
+                "127.0.0.1:1234/proxy",
+                RedapUri::Proxy(ProxyUri {
+                    origin: Origin {
+                        scheme: Scheme::RerunHttp,
+                        host: url::Host::Ipv4(Ipv4Addr::new(127, 0, 0, 1)),
+                        port: 1234,
+                    },
+                }),
+            ),
+        ];
+
+        for (url, expected) in test_cases {
+            assert_eq!(url.parse::<RedapUri>().unwrap(), expected);
+        }
+    }
 }

crates/viewer/re_redap_browser/src/servers.rs

@@ -190,7 +190,7 @@ impl RedapServers {
                     );
                 } else {
                     // Since we persist the server list on disk this happens quite often.
-                    // E.g. run `pixi run rerun "rerun+http://localhost:51234"` more than once.
+                    // E.g. run `pixi run rerun "rerun+http://localhost"` more than once.
                     re_log::debug!(
                         "Tried to add pre-existing server at {:?}",
                         origin.to_string()

docs/content/reference/sdk/operating-modes.md

@@ -12,11 +12,11 @@ Before reading this document, you might want to familiarize yourself with the [R
 
 ## Operating modes
 
-The Rerun SDK provides 4 modes of operation: `spawn`, `connect`, `serve`, and `save`.
+The Rerun SDK provides 4 modes of operation: `spawn`, `connect`, `serve_grpc`, and `save`.
 
 All four of them are optional: when none of these modes are active, the client will simply buffer the logged data in memory, waiting for one of these modes to be enabled so that it can flush it.
 
-### Spawn
+### `spawn`
 
 This is the default behavior you get when running all of our C++/Python/Rust examples, and is generally the most convenient when you're experimenting.
 
@@ -30,7 +30,7 @@ Call [`rr.spawn`](https://ref.rerun.io/docs/python/stable/common/initialization_
 [`RecordingStream::spawn`](https://docs.rs/rerun/latest/rerun/struct.RecordingStream.html#method.spawn) spawns a new Rerun Viewer process using an executable available in your PATH, then streams all the data to it via gRPC. If an external Viewer was already running, `spawn` will connect to that one instead of spawning a new one.
 
 
-### Connect
+### `connect`
 
 Connects to a remote Rerun Viewer and streams all the data via gRPC.
 
@@ -46,31 +46,28 @@ You will need to start a stand-alone Viewer first by typing `rerun` in your term
 [`RecordingStream::connect`](https://docs.rs/rerun/latest/rerun/struct.RecordingStream.html#method.connect)
 
 
-### Serve
+### `serve_grpc`
+Calling `serve_grpc` will start a Rerun gRPC server in your process, and stream logged data to it.
+This gRPC server can then be connected to from the Rerun Viewer, e.g. by running `rerun --connect localhost/proxy`.
+The gRPC server acts as a proxy, buffering and forwarding log data to the Rerun Viewer.
 
-There are two kinds of `serve` calls:
-
-* `serve_web`
-* `serve_grpc`
-
-Both will start a Rerun gRPC server in your process, and stream logged data to it.
-
-The `serve_web` call starts an additional server which hosts the assets required to run the Rerun Viewer in your browser.
+You can also connect to the gRPC server from a Rerun Web Viewer.
+To host a Rerun Web Viewer, you can use the `serve_web_viewer` function.
 
 #### C++
 * [`RecordingStream::serve_grpc`](https://ref.rerun.io/docs/cpp/stable/classrerun_1_1RecordingStream.html).
-* `serve_web` is not available.
+* `serve_web_viewer` is not available.
 
 #### Python
 * [`rr.serve_grpc`](https://ref.rerun.io/docs/python/stable/common/initialization_functions/#rerun.serve_grpc?speculative-link)
-* [`rr.serve_web`](https://ref.rerun.io/docs/python/stable/common/initialization_functions/#rerun.serve_web)
+* [`rr.serve_web_viewer`](https://ref.rerun.io/docs/python/stable/common/initialization_functions/#rerun.serve_web_viewer?speculative-link)
 
 #### Rust
 * [`RecordingStream::serve_grpc`](https://docs.rs/rerun/latest/rerun/struct.RecordingStream.html#method.serve_grpc?speculative-link)
-* [`RecordingStream::serve_web`](https://docs.rs/rerun/latest/rerun/struct.RecordingStream.html#method.serve_web?speculative-link)
+* [`RecordingStream::serve_web_viewer`](https://docs.rs/rerun/latest/rerun/struct.RecordingStream.html#method.serve_web_viewer?speculative-link)
 
 
-### Save
+### `save`
 
 Streams all logging data into an `.rrd` file on disk, which can then be loaded into a stand-alone viewer.
 

examples/rust/minimal_serve/src/main.rs

@@ -3,14 +3,13 @@
 use rerun::{demo_util::grid, external::glam};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let open_browser = true;
-    let rec = rerun::RecordingStreamBuilder::new("rerun_example_minimal_serve").serve_web(
-        "0.0.0.0",
-        Default::default(),
-        Default::default(),
-        rerun::MemoryLimit::from_fraction_of_total(0.25),
-        open_browser,
-    )?;
+    let rec = rerun::RecordingStreamBuilder::new("rerun_example_minimal_serve").serve_grpc()?;
+
+    rerun::serve_web_viewer(rerun::web_viewer::WebViewerConfig {
+        connect_to: Some("localhost/proxy".to_owned()),
+        ..Default::default()
+    })?
+    .detach();
 
     let points = grid(glam::Vec3::splat(-10.0), glam::Vec3::splat(10.0), 10);
     let colors = grid(glam::Vec3::ZERO, glam::Vec3::splat(255.0), 10)