revert re_log_encoding

Author: jprochazk

Cargo.lock

@@ -7165,9 +7165,6 @@ dependencies = [
  "re_smart_channel",
  "re_tracing",
  "re_types",
- "rmp-serde",
- "serde",
- "serde_bytes",
  "similar-asserts",
  "thiserror 1.0.65",
  "tokio",
@@ -8613,28 +8610,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "rmp"
-version = "0.8.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "228ed7c16fa39782c3b3468e974aec2795e9089153cd08ee2e9aefb3613334c4"
-dependencies = [
- "byteorder",
- "num-traits",
- "paste",
-]
-
-[[package]]
-name = "rmp-serde"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52e599a477cf9840e92f2cde9a7189e67b42c57532749bf90aea6ec10facd4db"
-dependencies = [
- "byteorder",
- "rmp",
- "serde",
-]
-
 [[package]]
 name = "ron"
 version = "0.8.1"
@@ -9094,15 +9069,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "serde_bytes"
-version = "0.11.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "serde_derive"
 version = "1.0.219"

crates/store/re_log_encoding/Cargo.toml

@@ -27,15 +27,12 @@ decoder = [
   "re_log_types/serde",
   "dep:bytes",
   "dep:lz4_flex",
-  "dep:rmp-serde",
-  "dep:serde",
-  "dep:serde_bytes",
   "dep:tokio",
   "dep:tokio-stream",
 ]
 
 ## Enable encoding of log messages to an .rrd file/stream.
-encoder = ["dep:rmp-serde", "dep:lz4_flex", "re_log_types/serde"]
+encoder = ["dep:lz4_flex", "re_log_types/serde"]
 
 ## Enable streaming of .rrd files from HTTP.
 stream_from_http = [
@@ -68,9 +65,6 @@ thiserror.workspace = true
 bytes = { workspace = true, optional = true }
 ehttp = { workspace = true, optional = true, features = ["streaming"] }
 lz4_flex = { workspace = true, optional = true }
-rmp-serde = { workspace = true, optional = true }                       # For loading legacy (pre 0.22) .rrd files
-serde = { workspace = true, optional = true }                           # For loading legacy (pre 0.22) .rrd files
-serde_bytes = { workspace = true, optional = true }                     # For loading legacy (pre 0.22) .rrd files
 tokio = { workspace = true, optional = true, features = ["io-util"] }
 tokio-stream = { workspace = true, optional = true }
 web-time = { workspace = true, optional = true }

crates/store/re_log_encoding/src/decoder/mod.rs

@@ -11,16 +11,15 @@ use std::io::Read as _;
 use re_build_info::CrateVersion;
 use re_log_types::LogMsg;
 
+use crate::codec;
 use crate::codec::file::decoder;
 use crate::FileHeader;
-use crate::LegacyMessageHeader;
 use crate::OLD_RRD_HEADERS;
-use crate::{codec, legacy::LegacyLogMsg};
-use crate::{Compression, EncodingOptions, Serializer};
+use crate::{EncodingOptions, Serializer};
 
 // ----------------------------------------------------------------------------
 
-fn warn_on_version_mismatch(encoded_version: [u8; 4]) {
+fn warn_on_version_mismatch(encoded_version: [u8; 4]) -> Result<(), DecodeError> {
     // We used 0000 for all .rrd files up until 2023-02-27, post 0.2.0 release:
     let encoded_version = if encoded_version == [0, 0, 0, 0] {
         CrateVersion::new(0, 2, 0)
@@ -30,11 +29,16 @@ fn warn_on_version_mismatch(encoded_version: [u8; 4]) {
 
     if encoded_version.major == 0 && encoded_version.minor < 23 {
         // We broke compatibility for 0.23 for (hopefully) the last time.
-        re_log::warn_once!("Attempting to load .rrd file from {encoded_version}…");
+        Err(DecodeError::IncompatibleRerunVersion {
+            file: encoded_version,
+            local: CrateVersion::LOCAL,
+        })
     } else if encoded_version <= CrateVersion::LOCAL {
         // Loading old files should be fine, and if it is not, the chunk migration in re_sorbet should already log a warning.
+        Ok(())
     } else {
         re_log::warn_once!("Found data stream with Rerun version {encoded_version} which is newer than the local Rerun version ({}). This file may contain data that is not compatible with this version of Rerun. Consider updating Rerun.", CrateVersion::LOCAL);
+        Ok(())
     }
 }
 
@@ -78,9 +82,6 @@ pub enum DecodeError {
     #[error("Arrow error: {0}")]
     Arrow(#[from] arrow::error::ArrowError),
 
-    #[error("MsgPack error: {0}")]
-    MsgPack(#[from] rmp_serde::decode::Error),
-
     #[error("Codec error: {0}")]
     Codec(#[from] codec::CodecError),
 }
@@ -139,10 +140,10 @@ pub fn options_from_bytes(bytes: &[u8]) -> Result<(CrateVersion, EncodingOptions
         return Err(DecodeError::NotAnRrd);
     }
 
-    warn_on_version_mismatch(version);
+    warn_on_version_mismatch(version)?;
 
     match options.serializer {
-        Serializer::LegacyMsgPack | Serializer::Protobuf => {}
+        Serializer::Protobuf => {}
     }
 
     Ok((CrateVersion::from_bytes(version), options))
@@ -167,8 +168,6 @@ pub struct Decoder<R: std::io::Read> {
     version: CrateVersion,
     options: EncodingOptions,
     read: Reader<R>,
-    uncompressed: Vec<u8>, // scratch space
-    compressed: Vec<u8>,   // scratch space
 
     /// The size in bytes of the data that has been decoded up to now.
     size_bytes: u64,
@@ -197,8 +196,6 @@ impl<R: std::io::Read> Decoder<R> {
             version,
             options,
             read: Reader::Raw(read),
-            uncompressed: vec![],
-            compressed: vec![],
             size_bytes: FileHeader::SIZE as _,
         })
     }
@@ -208,8 +205,6 @@ impl<R: std::io::Read> Decoder<R> {
             version,
             options,
             read: Reader::Raw(read),
-            uncompressed: vec![],
-            compressed: vec![],
             size_bytes: FileHeader::SIZE as _,
         }
     }
@@ -242,8 +237,6 @@ impl<R: std::io::Read> Decoder<R> {
             version,
             options,
             read: Reader::Buffered(read),
-            uncompressed: vec![],
-            compressed: vec![],
             size_bytes: FileHeader::SIZE as _,
         })
     }
@@ -323,78 +316,6 @@ impl<R: std::io::Read> Iterator for Decoder<R> {
                     _ => return Some(Err(err)),
                 },
             },
-            Serializer::LegacyMsgPack => {
-                let header = match LegacyMessageHeader::decode(&mut self.read) {
-                    Ok(header) => header,
-                    Err(err) => match err {
-                        DecodeError::Read(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
-                            return None;
-                        }
-                        other => return Some(Err(other)),
-                    },
-                };
-                self.size_bytes += LegacyMessageHeader::SIZE as u64;
-
-                match header {
-                    LegacyMessageHeader::Data {
-                        compressed_len,
-                        uncompressed_len,
-                    } => {
-                        let uncompressed_len = uncompressed_len as usize;
-                        let compressed_len = compressed_len as usize;
-
-                        self.uncompressed
-                            .resize(self.uncompressed.len().max(uncompressed_len), 0);
-
-                        match self.options.compression {
-                            Compression::Off => {
-                                re_tracing::profile_scope!("read uncompressed");
-                                if let Err(err) = self
-                                    .read
-                                    .read_exact(&mut self.uncompressed[..uncompressed_len])
-                                {
-                                    return Some(Err(DecodeError::Read(err)));
-                                }
-                                self.size_bytes += uncompressed_len as u64;
-                            }
-
-                            Compression::LZ4 => {
-                                self.compressed
-                                    .resize(self.compressed.len().max(compressed_len), 0);
-
-                                {
-                                    re_tracing::profile_scope!("read compressed");
-                                    if let Err(err) =
-                                        self.read.read_exact(&mut self.compressed[..compressed_len])
-                                    {
-                                        return Some(Err(DecodeError::Read(err)));
-                                    }
-                                }
-
-                                re_tracing::profile_scope!("lz4");
-                                if let Err(err) = lz4_flex::block::decompress_into(
-                                    &self.compressed[..compressed_len],
-                                    &mut self.uncompressed[..uncompressed_len],
-                                ) {
-                                    return Some(Err(DecodeError::Lz4(err)));
-                                }
-
-                                self.size_bytes += compressed_len as u64;
-                            }
-                        }
-
-                        let data = &self.uncompressed[..uncompressed_len];
-                        {
-                            re_tracing::profile_scope!("MsgPack deser");
-                            match rmp_serde::from_slice::<LegacyLogMsg>(data) {
-                                Ok(legacy_msg) => Some(legacy_msg.migrate()),
-                                Err(err) => return Some(Err(err.into())),
-                            }
-                        }
-                    }
-                    LegacyMessageHeader::EndOfStream => None,
-                }
-            }
         };
 
         let Some(mut msg) = msg else {
@@ -426,6 +347,8 @@ impl<R: std::io::Read> Iterator for Decoder<R> {
 mod tests {
     #![allow(clippy::unwrap_used)] // acceptable for tests
 
+    use crate::Compression;
+
     use super::*;
     use re_build_info::CrateVersion;
     use re_chunk::RowId;