Mark valid data ranges in timeline when loading data via range-limited URL (#11340)

Author: Wumpf

Cargo.lock

@@ -11541,6 +11541,7 @@ version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eab68b56840f69efb0fefbe3ab6661499217ffdc58e2eef7c3f6f69835386322"
 dependencies = [
+ "serde",
  "smallvec",
 ]
 

crates/store/re_log_types/src/lib.rs

@@ -583,6 +583,12 @@ pub struct StoreInfo {
     // NOTE: The version comes directly from the decoded RRD stream's header, duplicating it here
     // would probably only lead to more issues down the line.
     pub store_version: Option<CrateVersion>,
+
+    /// If true, the Viewer downloaded only a subset of an existing recording.
+    ///
+    /// This happens when opening URLs with a time range.
+    /// If we don't know for sure whether the recording is partial, we set this to `false`.
+    pub is_partial: bool,
 }
 
 impl StoreInfo {
@@ -593,6 +599,7 @@ impl StoreInfo {
             cloned_from: None,
             store_source,
             store_version: Some(CrateVersion::LOCAL),
+            is_partial: false,
         }
     }
 
@@ -603,6 +610,7 @@ impl StoreInfo {
             cloned_from: None,
             store_source,
             store_version: None,
+            is_partial: false,
         }
     }
 
@@ -949,6 +957,7 @@ impl SizeBytes for StoreInfo {
             cloned_from: _,
             store_source,
             store_version,
+            is_partial: _,
         } = self;
 
         store_id.heap_size_bytes()

crates/store/re_protos/src/v1alpha1/rerun.log_msg.v1alpha1.ext.rs

@@ -253,6 +253,7 @@ impl TryFrom<crate::log_msg::v1alpha1::StoreInfo> for re_log_types::StoreInfo {
             cloned_from: None,
             store_source,
             store_version,
+            is_partial: false,
         })
     }
 }

crates/store/re_redap_client/src/grpc.rs

@@ -1,8 +1,8 @@
 use re_auth::client::AuthDecorator;
-use re_chunk::Chunk;
+use re_chunk::{Chunk, TimelineName};
 use re_log_types::{
-    BlueprintActivationCommand, EntryId, LogMsg, SetStoreInfo, StoreId, StoreInfo, StoreKind,
-    StoreSource,
+    AbsoluteTimeRange, BlueprintActivationCommand, EntryId, LogMsg, SetStoreInfo, StoreId,
+    StoreInfo, StoreKind, StoreSource,
 };
 use re_protos::cloud::v1alpha1::GetChunksRequest;
 use re_protos::cloud::v1alpha1::ext::{Query, QueryLatestAt, QueryRange};
@@ -21,13 +21,16 @@ use crate::{
 ///
 /// If you're not in a ui context you can safely ignore these.
 pub enum UiCommand {
-    SetLoopSelection {
-        recording_id: re_log_types::StoreId,
-        timeline: re_log_types::Timeline,
-        time_range: re_log_types::AbsoluteTimeRangeF,
+    AddValidTimeRange {
+        store_id: StoreId,
+
+        /// If `None`, signals that all timelines are entirely valid.
+        timeline: Option<TimelineName>,
+        time_range: AbsoluteTimeRange,
     },
+
     SetUrlFragment {
-        recording_id: re_log_types::StoreId,
+        store_id: StoreId,
         fragment: re_uri::Fragment,
     },
 }
@@ -428,6 +431,7 @@ pub async fn stream_blueprint_and_partition_from_server(
             cloned_from: None,
             store_source: StoreSource::Unknown,
             store_version: None,
+            is_partial: false,
         };
 
         stream_partition_from_server(
@@ -460,13 +464,6 @@ pub async fn stream_blueprint_and_partition_from_server(
         re_log::debug!("No blueprint dataset found for {uri}");
     }
 
-    let store_info = StoreInfo {
-        store_id: recording_store_id,
-        cloned_from: None,
-        store_source: StoreSource::Unknown,
-        store_version: None,
-    };
-
     let re_uri::DatasetPartitionUri {
         origin: _,
         dataset_id,
@@ -475,6 +472,14 @@ pub async fn stream_blueprint_and_partition_from_server(
         fragment,
     } = uri;
 
+    let store_info = StoreInfo {
+        store_id: recording_store_id,
+        cloned_from: None,
+        store_source: StoreSource::Unknown,
+        store_version: None,
+        is_partial: time_range.is_some(),
+    };
+
     stream_partition_from_server(
         &mut client,
         store_info,
@@ -563,17 +568,27 @@ async fn stream_partition_from_server(
 
     let store_id = store_info.store_id.clone();
 
-    if let Some(on_ui_cmd) = on_ui_cmd {
+    // Send UI commands for recording (as opposed to blueprint) stores.
+    if let Some(on_ui_cmd) = on_ui_cmd
+        && store_info.store_id.is_recording()
+    {
         if let Some(time_range) = time_range {
-            on_ui_cmd(UiCommand::SetLoopSelection {
-                recording_id: store_id.clone(),
-                timeline: time_range.timeline,
+            on_ui_cmd(UiCommand::AddValidTimeRange {
+                store_id: store_id.clone(),
+                timeline: Some(*time_range.timeline.name()),
                 time_range: time_range.into(),
             });
+        } else {
+            on_ui_cmd(UiCommand::AddValidTimeRange {
+                store_id: store_id.clone(),
+                timeline: None,
+                time_range: AbsoluteTimeRange::EVERYTHING,
+            });
         }
+
         if !fragment.is_empty() {
             on_ui_cmd(UiCommand::SetUrlFragment {
-                recording_id: store_id.clone(),
+                store_id: store_id.clone(),
                 fragment,
             });
         }

crates/viewer/re_component_ui/src/variant_uis/redap_uri_button.rs

@@ -36,18 +36,18 @@ pub fn redap_uri_button(
 
     let uri = RedapUri::from_str(url_str)?;
 
-    let loaded_recording_id = ctx.storage_context.bundle.recordings().find_map(|db| {
+    let loaded_recording_info = ctx.storage_context.bundle.recordings().find_map(|db| {
         if db
             .data_source
             .as_ref()
             .is_some_and(|source| source.stripped_redap_uri().as_ref() == Some(&uri))
         {
-            Some(db.store_id().clone())
+            db.store_info()
         } else {
             None
         }
     });
-    let is_loading = loaded_recording_id.is_none()
+    let is_loading = loaded_recording_info.is_none()
         && ctx
             .connected_receivers
             .sources()
@@ -96,20 +96,31 @@ pub fn redap_uri_button(
             .0
     };
 
-    if let Some(loaded_recording_id) = loaded_recording_id {
-        let response = link_with_copy(ui, Link::new("Switch to")).on_hover_ui(|ui| {
-            ui.label("This recording is already loaded. Click to switch to it.");
-        });
+    ui.horizontal(|ui| {
+        if let Some(loaded_recording_info) = loaded_recording_info {
+            if loaded_recording_info.is_partial {
+                let response = ui.add(Link::new("Open full")).on_hover_text(
+                    "Part of this recording is already loaded. Click to download the rest.",
+                );
+                handle_open_full_recording_link(ui, uri, &response);
+            }
 
-        if response.clicked() {
-            // Show it:
-            ctx.command_sender()
-                .send_system(SystemCommand::SetSelection(
-                    re_viewer_context::Item::StoreId(loaded_recording_id).into(),
-                ));
-        }
-    } else if is_loading {
-        ui.horizontal(|ui| {
+            let response = link_with_copy(ui, Link::new("Switch to")).on_hover_text(
+                if loaded_recording_info.is_partial {
+                    "Part of this recording is already loaded. Click to switch to it."
+                } else {
+                    "This recording is already loaded. Click to switch to it."
+                },
+            );
+            if response.clicked() {
+                // Show it:
+                ctx.command_sender()
+                    .send_system(SystemCommand::SetSelection(
+                        re_viewer_context::Item::StoreId(loaded_recording_info.store_id.clone())
+                            .into(),
+                    ));
+            }
+        } else if is_loading {
             ui.spinner();
 
             if ui
@@ -119,18 +130,22 @@ pub fn redap_uri_button(
             {
                 ctx.connected_receivers.remove_by_uri(&uri.to_string());
             }
-        });
-    } else {
-        let response = link_with_copy(ui, Link::new("Open")).on_hover_ui(|ui| {
-            ui.label(uri.to_string());
-        });
+        } else {
+            let response = link_with_copy(ui, Link::new("Open")).on_hover_ui(|ui| {
+                ui.label(uri.to_string());
+            });
 
-        if response.clicked_with_open_in_background() {
-            ui.ctx().open_url(egui::OpenUrl::new_tab(uri));
-        } else if response.clicked() {
-            ui.ctx().open_url(egui::OpenUrl::same_tab(uri));
+            handle_open_full_recording_link(ui, uri, &response);
         }
-    }
+    });
 
     Ok(())
 }
+
+fn handle_open_full_recording_link(ui: &Ui, uri: RedapUri, response: &egui::Response) {
+    if response.clicked_with_open_in_background() {
+        ui.ctx().open_url(egui::OpenUrl::new_tab(uri));
+    } else if response.clicked() {
+        ui.ctx().open_url(egui::OpenUrl::same_tab(uri));
+    }
+}

crates/viewer/re_data_ui/src/entity_db.rs

@@ -53,6 +53,7 @@ impl crate::DataUi for EntityDb {
                     cloned_from,
                     store_source,
                     store_version,
+                    is_partial,
                 } = store_info;
 
                 if let Some(cloned_from) = cloned_from {
@@ -79,6 +80,15 @@ impl crate::DataUi for EntityDb {
                     );
                 }
 
+                // TODO(#11315): In the future we will want to reduce this to a mere highlighting feature and no longer need this at the store level
+                // as all data will be pulled on-demand from a server.
+                ui.grid_left_hand_label("Partial store");
+                ui.monospace(format!("{is_partial:?}"))
+                .on_hover_text(
+                    "If true, only a subset of the recording is presented in the viewer.",
+                );
+                ui.end_row();
+
                 ui.grid_left_hand_label("Kind");
                 ui.label(store_id.kind().to_string());
                 ui.end_row();

crates/viewer/re_data_ui/src/item_ui.rs

@@ -718,8 +718,17 @@ pub fn entity_db_button_ui(
     }
     .unwrap_or("<unknown>".to_owned());
 
+    let partial_postfix = if entity_db
+        .store_info()
+        .is_some_and(|store_info| store_info.is_partial)
+    {
+        " (partial)"
+    } else {
+        ""
+    };
+
     let size = re_format::format_bytes(entity_db.total_size_bytes() as _);
-    let title = format!("{app_id_prefix}{recording_name} - {size}");
+    let title = format!("{app_id_prefix}{recording_name}{partial_postfix} - {size}");
 
     let store_id = entity_db.store_id().clone();
     let item = re_viewer_context::Item::StoreId(store_id.clone());

crates/viewer/re_global_context/src/command_sender.rs

@@ -1,7 +1,7 @@
 use re_chunk::{EntityPath, Timeline};
 use re_chunk_store::external::re_chunk::Chunk;
 use re_data_source::LogDataSource;
-use re_log_types::{AbsoluteTimeRangeF, StoreId};
+use re_log_types::{AbsoluteTimeRange, AbsoluteTimeRangeF, StoreId};
 use re_ui::{UICommand, UICommandSender};
 
 use crate::RecordingOrTable;
@@ -126,6 +126,18 @@ pub enum SystemCommand {
         time_range: AbsoluteTimeRangeF,
     },
 
+    /// Mark a time range as valid.
+    ///
+    /// Everything outside can still be navigated to, but will be considered potentially lacking some data and therefore "invalid".
+    /// Visually, it is outside of the normal time range and shown greyed out.
+    ///
+    /// If timeline is `None`, this signals that all timelines are considered to be valid entirely.
+    AddValidTimeRange {
+        store_id: StoreId,
+        timeline: Option<re_chunk::TimelineName>,
+        time_range: AbsoluteTimeRange,
+    },
+
     /// Sets the focus to the given item.
     ///
     /// The focused item is cleared out every frame.

crates/viewer/re_selection_panel/tests/snapshots/selection_panel_recording.png

@@ -635,6 +635,19 @@ impl TestContext {
                     }
                 }
 
+                SystemCommand::AddValidTimeRange {
+                    store_id: rec_id,
+                    timeline,
+                    time_range,
+                } => {
+                    assert_eq!(
+                        &rec_id,
+                        self.store_hub.lock().active_recording().unwrap().store_id()
+                    );
+                    let mut time_ctrl = self.recording_config.time_ctrl.write();
+                    time_ctrl.mark_time_range_valid(timeline, time_range);
+                }
+
                 // not implemented
                 SystemCommand::ActivateApp(_)
                 | SystemCommand::ActivateRecordingOrTable(_)