Faster mcap recover CLI command

go/cli/mcap/cmd/filter.go

@@ -33,7 +33,6 @@ type filterFlags struct {
 }
 
 type filterOpts struct {
-	recover            bool
 	output             string
 	includeTopics      []regexp.Regexp
 	excludeTopics      []regexp.Regexp
@@ -224,7 +223,6 @@ func filter(
 
 	lexer, err := mcap.NewLexer(r, &mcap.LexerOptions{
 		ValidateChunkCRCs: true,
-		EmitInvalidChunks: opts.recover,
 		AttachmentCallback: func(ar *mcap.AttachmentReader) error {
 			if !opts.includeAttachments {
 				return nil
@@ -260,15 +258,6 @@ func filter(
 			fmt.Fprintf(os.Stderr, "failed to close mcap writer: %v\n", err)
 			return
 		}
-		if opts.recover {
-			fmt.Fprintf(
-				os.Stderr,
-				"Recovered %d messages, %d attachments, and %d metadata records.\n",
-				numMessages,
-				numAttachments,
-				numMetadata,
-			)
-		}
 	}()
 
 	buf := make([]byte, 1024)
@@ -281,17 +270,6 @@ func filter(
 			if errors.Is(err, io.EOF) {
 				return nil
 			}
-			if opts.recover {
-				var expected *mcap.ErrTruncatedRecord
-				if errors.As(err, &expected) {
-					fmt.Println(expected.Error())
-					return nil
-				}
-				if token == mcap.TokenInvalidChunk {
-					fmt.Printf("Invalid chunk encountered, skipping: %s\n", err)
-					continue
-				}
-			}
 			return err
 		}
 		if len(data) > len(buf) {
@@ -504,39 +482,6 @@ usage:
 		rootCmd.AddCommand(filterCmd)
 	}
 
-	{
-		var recoverCmd = &cobra.Command{
-			Use:   "recover [file]",
-			Short: "Recover data from a potentially corrupt MCAP file",
-			Long: `This subcommand reads a potentially corrupt MCAP file and copies data to a new file.
-
-usage:
-  mcap recover in.mcap -o out.mcap`,
-		}
-		output := recoverCmd.PersistentFlags().StringP("output", "o", "", "output filename")
-		chunkSize := recoverCmd.PersistentFlags().Int64P("chunk-size", "", 4*1024*1024, "chunk size of output file")
-		compression := recoverCmd.PersistentFlags().String(
-			"compression",
-			"zstd",
-			"compression algorithm to use on output file",
-		)
-		recoverCmd.Run = func(_ *cobra.Command, args []string) {
-			filterOptions, err := buildFilterOptions(&filterFlags{
-				output:             *output,
-				chunkSize:          *chunkSize,
-				outputCompression:  *compression,
-				includeMetadata:    true,
-				includeAttachments: true,
-			})
-			if err != nil {
-				die("configuration error: %s", err)
-			}
-			filterOptions.recover = true
-			run(filterOptions, args)
-		}
-		rootCmd.AddCommand(recoverCmd)
-	}
-
 	{
 		var compressCmd = &cobra.Command{
 			Use:   "compress [file]",

go/cli/mcap/cmd/filter_test.go

@@ -257,110 +257,6 @@ func TestFiltering(t *testing.T) {
 	}
 }
 
-func TestRecover(t *testing.T) {
-	t.Run("recover data from truncated file", func(t *testing.T) {
-		writeBuf := bytes.Buffer{}
-		readBuf := bytes.Buffer{}
-		writeFilterTestInput(t, &readBuf)
-		readBuf.Truncate(readBuf.Len() / 2)
-
-		require.NoError(t, filter(&readBuf, &writeBuf, &filterOpts{
-			end:                1000,
-			recover:            true,
-			includeAttachments: true,
-			includeMetadata:    true,
-		}))
-
-		messageCounter := map[uint16]int{
-			1: 0,
-			2: 0,
-			3: 0,
-		}
-		attachmentCounter := 0
-		metadataCounter := 0
-		lexer, err := mcap.NewLexer(&writeBuf, &mcap.LexerOptions{
-			AttachmentCallback: func(*mcap.AttachmentReader) error {
-				attachmentCounter++
-				return nil
-			},
-		})
-		require.NoError(t, err)
-		defer lexer.Close()
-		for {
-			token, record, err := lexer.Next(nil)
-			if err != nil {
-				require.ErrorIs(t, err, io.EOF)
-				break
-			}
-			switch token {
-			case mcap.TokenMessage:
-				message, err := mcap.ParseMessage(record)
-				require.NoError(t, err)
-				messageCounter[message.ChannelID]++
-			case mcap.TokenMetadata:
-				metadataCounter++
-			}
-		}
-		assert.Equal(t, 0, attachmentCounter)
-		assert.Equal(t, 0, metadataCounter)
-		assert.InDeltaMapValues(t, map[uint16]int{
-			1: 88,
-			2: 88,
-			3: 88,
-		}, messageCounter, 0.0)
-	})
-
-	t.Run("recover data from chunk with invalid crc", func(t *testing.T) {
-		writeBuf := bytes.Buffer{}
-		readBuf := bytes.Buffer{}
-		writeFilterTestInput(t, &readBuf)
-		readBuf.Bytes()[0x12b] = 1 // overwrite crc
-
-		require.NoError(t, filter(&readBuf, &writeBuf, &filterOpts{
-			end:                1000,
-			recover:            true,
-			includeAttachments: true,
-			includeMetadata:    true,
-		}))
-		messageCounter := map[uint16]int{
-			1: 0,
-			2: 0,
-			3: 0,
-		}
-		attachmentCounter := 0
-		metadataCounter := 0
-		lexer, err := mcap.NewLexer(&writeBuf, &mcap.LexerOptions{
-			AttachmentCallback: func(_ *mcap.AttachmentReader) error {
-				attachmentCounter++
-				return nil
-			},
-		})
-		require.NoError(t, err)
-		for {
-			token, record, err := lexer.Next(nil)
-			if err != nil {
-				require.ErrorIs(t, err, io.EOF)
-				break
-			}
-			switch token {
-			case mcap.TokenMessage:
-				message, err := mcap.ParseMessage(record)
-				require.NoError(t, err)
-				messageCounter[message.ChannelID]++
-			case mcap.TokenMetadata:
-				metadataCounter++
-			}
-		}
-		assert.Equal(t, 1, attachmentCounter)
-		assert.Equal(t, 1, metadataCounter)
-		assert.InDeltaMapValues(t, map[uint16]int{
-			1: 100,
-			2: 99,
-			3: 100,
-		}, messageCounter, 0.0)
-	})
-}
-
 func TestCompileMatchers(t *testing.T) {
 	matchers, err := compileMatchers([]string{"camera.*", "lights.*"})
 	require.NoError(t, err)