re_uri: Use correct default port (51234, not 80) (#9468)

This makes it more ergonomic to connect to redap.

Also: use more idiomatic `FromStr` instead of `TryFrom<&str>`. I've
opened a clippy lint about this:
rust-lang/rust-clippy#14522

Review each commit seperately.

Author: emilk

crates/store/re_data_source/src/data_source.rs

@@ -102,7 +102,7 @@ impl DataSource {
             }
         }
 
-        if let Ok(endpoint) = re_uri::RedapUri::try_from(uri.as_str()) {
+        if let Ok(endpoint) = uri.as_str().parse::<re_uri::RedapUri>() {
             return Self::RerunGrpcStream(endpoint);
         }
 

crates/store/re_log_types/src/path/entity_path_filter.rs

@@ -61,12 +61,10 @@ pub struct EntityPathFilter {
     rules: BTreeMap<EntityPathRule, RuleEffect>,
 }
 
-// Note: it's not possible to implement that for `S: AsRef<str>` because this conflicts with some
-// blanket implementation in `core` :(
-impl TryFrom<&str> for EntityPathFilter {
-    type Error = EntityPathFilterError;
+impl std::str::FromStr for EntityPathFilter {
+    type Err = EntityPathFilterError;
 
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
         Self::parse_strict(value)
     }
 }

crates/top/re_sdk/src/recording_stream.rs

@@ -384,8 +384,7 @@ impl RecordingStreamBuilder {
         let (enabled, store_info, properties, batcher_config) = self.into_args();
         if enabled {
             let url: String = url.into();
-            let re_uri::RedapUri::Proxy(endpoint) = re_uri::RedapUri::try_from(url.as_str())?
-            else {
+            let re_uri::RedapUri::Proxy(endpoint) = url.as_str().parse()? else {
                 return Err(RecordingStreamError::NotAProxyEndpoint);
             };
 
@@ -1809,7 +1808,7 @@ impl RecordingStream {
         }
 
         let url: String = url.into();
-        let re_uri::RedapUri::Proxy(endpoint) = re_uri::RedapUri::try_from(url.as_str())? else {
+        let re_uri::RedapUri::Proxy(endpoint) = url.as_str().parse()? else {
             return Err(RecordingStreamError::NotAProxyEndpoint);
         };
 

crates/top/rerun/src/commands/entrypoint.rs

@@ -762,8 +762,7 @@ fn run_impl(
         #[cfg(feature = "server")]
         if let Some(url) = args.connect {
             let url = url.unwrap_or_else(|| format!("rerun+http://{server_addr}/proxy"));
-            let re_uri::RedapUri::Proxy(endpoint) = re_uri::RedapUri::try_from(url.as_str())?
-            else {
+            let re_uri::RedapUri::Proxy(endpoint) = url.as_str().parse()? else {
                 anyhow::bail!("expected `/proxy` endpoint");
             };
             let rx = re_sdk::external::re_grpc_client::message_proxy::stream(endpoint, None);
@@ -857,8 +856,7 @@ fn run_impl(
                 format!("rerun+http://{server_addr}/proxy")
             };
 
-            let re_uri::RedapUri::Proxy(endpoint) = re_uri::RedapUri::try_from(url.as_str())?
-            else {
+            let re_uri::RedapUri::Proxy(endpoint) = url.as_str().parse()? else {
                 anyhow::bail!("expected `/proxy` endpoint");
             };
 

crates/utils/re_uri/src/redap_uri.rs

@@ -1,4 +1,4 @@
-use std::str::FromStr as _;
+use std::str::FromStr;
 
 use re_log_types::{TimeCell, TimeInt};
 
@@ -27,10 +27,10 @@ impl std::fmt::Display for TimeRange {
     }
 }
 
-impl TryFrom<&str> for TimeRange {
-    type Error = Error;
+impl FromStr for TimeRange {
+    type Err = Error;
 
-    fn try_from(value: &str) -> Result<Self, crate::Error> {
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
         let (timeline, range) = value
             .split_once('@')
             .ok_or_else(|| Error::InvalidTimeRange("Missing @".to_owned()))?;
@@ -111,10 +111,10 @@ impl Scheme {
     }
 }
 
-impl TryFrom<&str> for Scheme {
-    type Error = Error;
+impl FromStr for Scheme {
+    type Err = Error;
 
-    fn try_from(url: &str) -> Result<Self, crate::Error> {
+    fn from_str(url: &str) -> Result<Self, Self::Err> {
         if url.starts_with("rerun://") {
             Ok(Self::Rerun)
         } else if url.starts_with("rerun+http://") {
@@ -158,13 +158,18 @@ impl crate::Origin {
 /// Parses a URL and returns the [`crate::Origin`] and the canonical URL (i.e. one that
 ///  starts with `http://` or `https://`).
 fn replace_and_parse(value: &str) -> Result<(crate::Origin, url::Url), Error> {
-    let scheme = Scheme::try_from(value)?;
+    let scheme = Scheme::from_str(value)?;
     let rewritten = scheme.canonical_url(value);
 
     // 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 http_url = url::Url::parse(&rewritten)?;
+    let mut http_url = url::Url::parse(&rewritten)?;
+
+    if http_url.port().is_none() {
+        // If no port is specified, we assume the default redap port:
+        http_url.set_port(Some(51234)).ok();
+    }
 
     let url::Origin::Tuple(_, host, port) = http_url.origin() else {
         return Err(Error::UnexpectedOpaqueOrigin(value.to_owned()));
@@ -175,10 +180,10 @@ fn replace_and_parse(value: &str) -> Result<(crate::Origin, url::Url), Error> {
     Ok((origin, http_url))
 }
 
-impl TryFrom<&str> for crate::Origin {
-    type Error = Error;
+impl FromStr for crate::Origin {
+    type Err = Error;
 
-    fn try_from(value: &str) -> Result<Self, crate::Error> {
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
         replace_and_parse(value).map(|(origin, _)| origin)
     }
 }
@@ -213,15 +218,7 @@ impl std::fmt::Display for RedapUri {
 impl std::str::FromStr for RedapUri {
     type Err = Error;
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::try_from(s)
-    }
-}
-
-impl TryFrom<&str> for RedapUri {
-    type Error = Error;
-
-    fn try_from(value: &str) -> Result<Self, crate::Error> {
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
         let (origin, http_url) = replace_and_parse(value)?;
 
         // :warning: We limit the amount of segments, which might need to be
@@ -236,7 +233,7 @@ impl TryFrom<&str> for RedapUri {
         let time_range = http_url
             .query_pairs()
             .find(|(key, _)| key == TimeRange::QUERY_KEY)
-            .map(|(_, value)| TimeRange::try_from(value.as_ref()));
+            .map(|(_, value)| TimeRange::from_str(value.as_ref()));
 
         match segments.as_slice() {
             ["proxy"] => Ok(Self::Proxy(ProxyEndpoint::new(origin))),
@@ -306,7 +303,7 @@ mod tests {
     fn test_dataset_data_url_to_address() {
         let url =
             "rerun://127.0.0.1:1234/dataset/1830B33B45B963E7774455beb91701ae/data?partition_id=pid";
-        let address: RedapUri = url.try_into().unwrap();
+        let address: RedapUri = url.parse().unwrap();
 
         let RedapUri::DatasetData(DatasetDataEndpoint {
             origin,
@@ -332,7 +329,7 @@ mod tests {
     #[test]
     fn test_dataset_data_url_time_range_sequence_to_address() {
         let url = "rerun://127.0.0.1:1234/dataset/1830B33B45B963E7774455beb91701ae/data?partition_id=pid&[email protected]";
-        let address: RedapUri = url.try_into().unwrap();
+        let address: RedapUri = url.parse().unwrap();
 
         let RedapUri::DatasetData(DatasetDataEndpoint {
             origin,
@@ -367,7 +364,7 @@ mod tests {
     #[test]
     fn test_dataset_data_url_time_range_timepoint_to_address() {
         let url = "rerun://127.0.0.1:1234/dataset/1830B33B45B963E7774455beb91701ae/data?partition_id=pid&time_range=log_time@2022-01-01T00:00:03.123456789Z..2022-01-01T00:00:13.123456789Z";
-        let address: RedapUri = url.try_into().unwrap();
+        let address: RedapUri = url.parse().unwrap();
 
         let RedapUri::DatasetData(DatasetDataEndpoint {
             origin,
@@ -409,7 +406,7 @@ mod tests {
             "rerun://127.0.0.1:1234/dataset/1830B33B45B963E7774455beb91701ae/data?partition_id=pid&[email protected]",
             "rerun://127.0.0.1:1234/dataset/1830B33B45B963E7774455beb91701ae/data?partition_id=pid&[email protected]",
         ] {
-            let address: RedapUri = url.try_into().unwrap();
+            let address: RedapUri = url.parse().unwrap();
 
             let RedapUri::DatasetData(DatasetDataEndpoint {
                 origin,
@@ -446,13 +443,13 @@ mod tests {
     fn test_dataset_data_url_missing_partition_id() {
         let url = "rerun://127.0.0.1:1234/dataset/1830B33B45B963E7774455beb91701ae/data";
 
-        assert!(RedapUri::try_from(url).is_err());
+        assert!(RedapUri::from_str(url).is_err());
     }
 
     #[test]
     fn test_http_catalog_url_to_address() {
         let url = "rerun+http://127.0.0.1:50051/catalog";
-        let address: RedapUri = url.try_into().unwrap();
+        let address: RedapUri = url.parse().unwrap();
         assert!(matches!(
             address,
             RedapUri::Catalog(CatalogEndpoint {
@@ -468,7 +465,7 @@ mod tests {
     #[test]
     fn test_https_catalog_url_to_address() {
         let url = "rerun+https://127.0.0.1:50051/catalog";
-        let address: RedapUri = url.try_into().unwrap();
+        let address: RedapUri = url.parse().unwrap();
 
         assert!(matches!(
             address,
@@ -485,7 +482,7 @@ mod tests {
     #[test]
     fn test_localhost_url() {
         let url = "rerun+http://localhost:51234/catalog";
-        let address = RedapUri::try_from(url).unwrap();
+        let address = RedapUri::from_str(url).unwrap();
 
         assert_eq!(
             address,
@@ -502,7 +499,7 @@ mod tests {
     #[test]
     fn test_invalid_url() {
         let url = "http://wrong-scheme:1234/recording/12345";
-        let address: Result<RedapUri, _> = url.try_into();
+        let address: Result<RedapUri, _> = url.parse();
 
         assert!(matches!(
             address.unwrap_err(),
@@ -513,7 +510,7 @@ mod tests {
     #[test]
     fn test_invalid_path() {
         let url = "rerun://0.0.0.0:51234/redap/recordings/12345";
-        let address: Result<RedapUri, _> = url.try_into();
+        let address: Result<RedapUri, _> = url.parse();
 
         assert!(matches!(
             address.unwrap_err(),
@@ -524,7 +521,7 @@ mod tests {
     #[test]
     fn test_proxy_endpoint() {
         let url = "rerun://localhost:51234/proxy";
-        let address: Result<RedapUri, _> = url.try_into();
+        let address: Result<RedapUri, _> = url.parse();
 
         let expected = RedapUri::Proxy(ProxyEndpoint {
             origin: Origin {
@@ -537,15 +534,15 @@ mod tests {
         assert_eq!(address.unwrap(), expected);
 
         let url = "rerun://localhost:51234/proxy/";
-        let address: Result<RedapUri, _> = url.try_into();
+        let address: Result<RedapUri, _> = url.parse();
 
         assert_eq!(address.unwrap(), expected);
     }
 
     #[test]
     fn test_catalog_default() {
         let url = "rerun://localhost:51234";
-        let address: Result<RedapUri, _> = url.try_into();
+        let address: Result<RedapUri, _> = url.parse();
 
         let expected = RedapUri::Catalog(CatalogEndpoint {
             origin: Origin {
@@ -558,8 +555,38 @@ mod tests {
         assert_eq!(address.unwrap(), expected);
 
         let url = "rerun://localhost:51234/";
-        let address: Result<RedapUri, _> = url.try_into();
+        let address: Result<RedapUri, _> = url.parse();
 
         assert_eq!(address.unwrap(), expected);
     }
+
+    #[test]
+    fn test_default_port() {
+        let url = "rerun://localhost";
+
+        let expected = RedapUri::Catalog(CatalogEndpoint {
+            origin: Origin {
+                scheme: Scheme::Rerun,
+                host: url::Host::Domain("localhost".to_owned()),
+                port: 51234,
+            },
+        });
+
+        assert_eq!(url.parse::<RedapUri>().unwrap(), expected);
+    }
+
+    #[test]
+    fn test_custom_port() {
+        let url = "rerun://localhost:123";
+
+        let expected = RedapUri::Catalog(CatalogEndpoint {
+            origin: Origin {
+                scheme: Scheme::Rerun,
+                host: url::Host::Domain("localhost".to_owned()),
+                port: 123,
+            },
+        });
+
+        assert_eq!(url.parse::<RedapUri>().unwrap(), expected);
+    }
 }

crates/viewer/re_blueprint_tree/tests/blueprint_tree_tests.rs

@@ -152,7 +152,7 @@ fn setup_filter_test(query: Option<&str>) -> (TestContext, BlueprintTree) {
                 re_view_spatial::SpatialView3D::identifier(),
                 RecommendedView {
                     origin: "/path/to".into(),
-                    query_filter: "+ /**".try_into().expect("valid entity path filter"),
+                    query_filter: "+ /**".parse().expect("valid entity path filter"),
                 },
             )),
             None,

crates/viewer/re_blueprint_tree/tests/view_structure_test.rs

@@ -128,7 +128,7 @@ fn test_context(test_case: &TestCase) -> TestContext {
                 origin: test_case.origin.clone(),
                 query_filter: test_case
                     .entity_filter
-                    .try_into()
+                    .parse()
                     .expect("invalid entity filter"),
             },
             ViewId::hashed_from_str(VIEW_ID),

crates/viewer/re_view_spatial/tests/transform_clamping.rs

@@ -163,15 +163,15 @@ fn setup_blueprint(test_context: &mut TestContext) -> (ViewId, ViewId) {
             re_view_spatial::SpatialView3D::identifier(),
             RecommendedView {
                 origin: "/boxes".into(),
-                query_filter: "+ $origin/**".try_into().unwrap(),
+                query_filter: "+ $origin/**".parse().unwrap(),
             },
         );
 
         let view_blueprint_spheres = ViewBlueprint::new(
             re_view_spatial::SpatialView3D::identifier(),
             RecommendedView {
                 origin: "/spheres".into(),
-                query_filter: "+ $origin/**".try_into().unwrap(),
+                query_filter: "+ $origin/**".parse().unwrap(),
             },
         );
 

crates/viewer/re_viewer/src/app_state.rs

@@ -895,7 +895,7 @@ fn check_for_clicked_hyperlinks(ctx: &ViewerContext<'_>) {
     ctx.egui_ctx().output_mut(|o| {
         o.commands.retain_mut(|command| {
             if let egui::OutputCommand::OpenUrl(open_url) = command {
-                let is_rerun_url = re_uri::RedapUri::try_from(open_url.url.as_ref()).is_ok();
+                let is_rerun_url = open_url.url.parse::<re_uri::RedapUri>().is_ok();
 
                 if is_rerun_url {
                     let data_source = re_data_source::DataSource::from_uri(

crates/viewer/re_viewer/src/web_tools.rs

@@ -99,7 +99,7 @@ enum EndpointCategory {
 
 impl EndpointCategory {
     fn categorize_uri(uri: String) -> Self {
-        if let Ok(uri) = re_uri::RedapUri::try_from(uri.as_ref()) {
+        if let Ok(uri) = uri.parse() {
             return Self::RerunGrpcStream(uri);
         }
 

examples/rust/dataframe_query/src/main.rs

@@ -3,7 +3,7 @@
 use itertools::Itertools;
 
 use rerun::{
-    dataframe::{EntityPathFilter, QueryEngine, QueryExpression, SparseFillStrategy, TimelineName},
+    dataframe::{QueryEngine, QueryExpression, SparseFillStrategy, TimelineName},
     external::{arrow, re_format_arrow::format_record_batch},
     ChunkStoreConfig, StoreKind, VersionPolicy,
 };
@@ -37,7 +37,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     let path_to_rrd = get_arg(1);
-    let entity_path_filter = EntityPathFilter::try_from(args.get(2).map_or("/**", |s| s.as_str()))?;
+    let entity_path_filter = args.get(2).map_or("/**", |s| s.as_str()).parse()?;
     let timeline = TimelineName::log_time();
 
     let engines = QueryEngine::from_rrd_filepath(

rerun_py/src/catalog/catalog_client.rs

@@ -26,7 +26,7 @@ impl PyCatalogClient {
     /// Create a new catalog client object.
     #[new]
     fn new(py: Python<'_>, addr: String) -> PyResult<Self> {
-        let origin = re_uri::Origin::try_from(addr.as_str()).map_err(to_py_err)?;
+        let origin = addr.as_str().parse::<re_uri::Origin>().map_err(to_py_err)?;
 
         let connection = ConnectionHandle::new(py, origin.clone())?;