Use bgpkit-parser v0.20.0 upstream text dump module

CHANGELOG.md

@@ -15,6 +15,16 @@ All notable changes to this project will be documented in this file.
 
 ### Code Improvements
 
+* Replaced Monocle's local Cisco `sh ip bgp` text dump implementation
+  (783-line `src/lens/parse/text_dump.rs`) with a re-export of the upstream
+  `bgpkit_parser::parser::text_dump` module (bgpkit-parser v0.20.0). The
+  `monocle::lens::parse::text_dump::*` paths are unchanged, so the `parse`
+  command's format auto-detection and timestamp inference work identically.
+  The parser now carries the text dump test coverage (17 tests).
+* Updated `export_bytes()`/`process_elem()` call sites in `monocle parse` and
+  `monocle search` MRT export for bgpkit-parser v0.20.0's fallible encoding
+  API: encoding errors are reported instead of silently truncating (upstream
+  issue #313).
 * Removed unused `radar-rs` dependency (Cloudflare Radar API support was
   removed during the lens refactor but the Cargo.toml entry survived).
 * Fixed `bgpkit-parser` dev-dependency version conflict: `[dev-dependencies]`

Cargo.toml

@@ -157,7 +157,7 @@ chrono-humanize = { version = "0.2", optional = true }
 dateparser = { version = "0.2", optional = true }
 humantime = { version = "2.1", optional = true }
 bgpkit-broker = { version = "0.10.1", optional = true }
-bgpkit-parser = { version = "0.19.0", features = ["serde"], optional = true }
+bgpkit-parser = { version = "0.20.0", features = ["serde"], optional = true }
 bgpkit-commons = { version = "0.12.0", features = ["asinfo", "rpki", "countries"], optional = true }
 itertools = { version = "0.14", optional = true }
 rayon = { version = "1.8", optional = true }

src/bin/commands/parse.rs

@@ -245,37 +245,43 @@ pub fn run(args: ParseArgs, output_format: OutputFormat) {
             MrtType::Rib => {
                 let mut encoder = MrtRibEncoder::new();
                 for (elem, _) in &elems {
-                    encoder.process_elem(elem);
+                    if let Err(e) = encoder.process_elem(elem) {
+                        eprintln!("Failed to encode element: {}", e);
+                    }
                 }
-                let bytes = encoder.export_bytes();
-                match oneio::get_writer(mrt_out_str) {
-                    Ok(mut w) => {
-                        if let Err(e) = w.write_all(&bytes) {
-                            eprintln!("Failed to write MRT data: {}", e);
+                match encoder.export_bytes() {
+                    Ok(bytes) => match oneio::get_writer(mrt_out_str) {
+                        Ok(mut w) => {
+                            if let Err(e) = w.write_all(&bytes) {
+                                eprintln!("Failed to write MRT data: {}", e);
+                            }
                         }
-                    }
-                    Err(e) => {
-                        eprintln!("Failed to create MRT writer: {}", e);
-                        std::process::exit(1);
-                    }
+                        Err(e) => {
+                            eprintln!("Failed to create MRT writer: {}", e);
+                            std::process::exit(1);
+                        }
+                    },
+                    Err(e) => eprintln!("Failed to encode MRT data: {}", e),
                 }
             }
             MrtType::Updates => {
                 let mut encoder = MrtUpdatesEncoder::new();
                 for (elem, _) in &elems {
                     encoder.process_elem(elem);
                 }
-                let bytes = encoder.export_bytes();
-                match oneio::get_writer(mrt_out_str) {
-                    Ok(mut w) => {
-                        if let Err(e) = w.write_all(&bytes) {
-                            eprintln!("Failed to write MRT data: {}", e);
+                match encoder.export_bytes() {
+                    Ok(bytes) => match oneio::get_writer(mrt_out_str) {
+                        Ok(mut w) => {
+                            if let Err(e) = w.write_all(&bytes) {
+                                eprintln!("Failed to write MRT data: {}", e);
+                            }
                         }
-                    }
-                    Err(e) => {
-                        eprintln!("Failed to create MRT writer: {}", e);
-                        std::process::exit(1);
-                    }
+                        Err(e) => {
+                            eprintln!("Failed to create MRT writer: {}", e);
+                            std::process::exit(1);
+                        }
+                    },
+                    Err(e) => eprintln!("Failed to encode MRT data: {}", e),
                 }
             }
         }

src/bin/commands/search.rs

@@ -887,9 +887,13 @@ fn run_inner(config: &MonocleConfig, args: SearchArgs, output_format: OutputForm
         }
 
         if let Some((encoder, writer)) = &mut mrt_writer {
-            let bytes = encoder.export_bytes();
-            if let Err(e) = writer.write_all(&bytes) {
-                eprintln!("Failed to write MRT data: {}", e);
+            match encoder.export_bytes() {
+                Ok(bytes) => {
+                    if let Err(e) = writer.write_all(&bytes) {
+                        eprintln!("Failed to write MRT data: {}", e);
+                    }
+                }
+                Err(e) => eprintln!("Failed to encode MRT data: {}", e),
             }
         }
         drop(mrt_writer);