···

       
400
       
400
       
 
       
            return Either::Right(std::iter::empty());

     

       
401
       
401
       
 
       
        };

     

       
402
       
402
       
 
       


     

       
403
       
403
       
-
       
        let mut ts = CLOCK.now();

     

       
403
       
403
       
+
       
        // let mut ts = CLOCK.now();

     

       
404
       
404
       
 
       
        let map_block = move |(key, val)| {

     

       
405
       
405
       
 
       
            let mut key_reader = Cursor::new(key);

     

       
406
       
406
       
 
       
            let start_timestamp = key_reader.read_varint::<u64>()?;

     

       
407
       
407
       
-
       
            let end_timestamp = key_reader.read_varint::<u64>()?;

     

       
407
       
407
       
+
       
            // let end_timestamp = key_reader.read_varint::<u64>()?;

     

       
408
       
408
       
 
       
            if start_timestamp < start_limit {

     

       
409
       
409
       
-
       
                tracing::info!(

     

       
410
       
410
       
-
       
                    "skipped block with timestamps {start_timestamp}..{end_timestamp} because {start_limit} is greater"

     

       
411
       
411
       
-
       
                );

     

       
409
       
409
       
+
       
                // tracing::info!(

     

       
410
       
410
       
+
       
                //     "skipped block with timestamps {start_timestamp}..{end_timestamp} because {start_limit} is greater"

     

       
411
       
411
       
+
       
                // );

     

       
412
       
412
       
 
       
                return Ok(None);

     

       
413
       
413
       
 
       
            } else {

     

       
414
       
414
       
-
       
                tracing::info!("using block with timestamp {start_timestamp}..{end_timestamp}");

     

       
414
       
414
       
+
       
                // tracing::info!("using block with timestamp {start_timestamp}..{end_timestamp}");

     

       
415
       
415
       
 
       
            }

     

       
416
       
416
       
 
       
            let decoder = handle::ItemDecoder::new(Cursor::new(val), start_timestamp)?;

     

       
417
       
417
       
-
       
            tracing::info!(

     

       
418
       
418
       
-
       
                "took {}ns to get block with size {}",

     

       
419
       
419
       
-
       
                ts.elapsed().as_nanos(),

     

       
420
       
420
       
-
       
                decoder.item_count()

     

       
421
       
421
       
-
       
            );

     

       
422
       
422
       
-
       
            ts = CLOCK.now();

     

       
417
       
417
       
+
       
            // tracing::info!(

     

       
418
       
418
       
+
       
            //     "took {}ns to get block with size {}",

     

       
419
       
419
       
+
       
            //     ts.elapsed().as_nanos(),

     

       
420
       
420
       
+
       
            //     decoder.item_count()

     

       
421
       
421
       
+
       
            // );

     

       
422
       
422
       
+
       
            // ts = CLOCK.now();

     

       
423
       
423
       
 
       
            Ok(Some(

     

       
424
       
424
       
 
       
                decoder

     

       
425
       
425
       
 
       
                    .take_while(move |item| {

     
···

       
431
       
431
       
 
       
            ))

     

       
432
       
432
       
 
       
        };

     

       
433
       
433
       
 
       


     

       
434
       
434
       
-
       
        Either::Left(

     

       
435
       
435
       
-
       
            handle

     

       
436
       
436
       
-
       
                .range(..end_key)

     

       
437
       
437
       
-
       
                .rev()

     

       
438
       
438
       
-
       
                .map_while(move |res| res.map_err(AppError::from).and_then(map_block).transpose())

     

       
439
       
439
       
-
       
                .collect::<Vec<_>>()

     

       
440
       
440
       
-
       
                .into_iter()

     

       
441
       
441
       
-
       
                .rev()

     

       
442
       
442
       
-
       
                .flatten()

     

       
443
       
443
       
-
       
                .flatten(),

     

       
444
       
444
       
-
       
        )

     

       
434
       
434
       
+
       
        let blocks = handle

     

       
435
       
435
       
+
       
            .range(..end_key)

     

       
436
       
436
       
+
       
            .rev()

     

       
437
       
437
       
+
       
            .map_while(move |res| res.map_err(AppError::from).and_then(map_block).transpose())

     

       
438
       
438
       
+
       
            .collect::<Vec<_>>();

     

       
439
       
439
       
+
       


     

       
440
       
440
       
+
       
        tracing::info!("returning {} blocks", blocks.len());

     

       
441
       
441
       
+
       


     

       
442
       
442
       
+
       
        Either::Left(blocks.into_iter().rev().flatten().flatten())

     

       
445
       
443
       
 
       
    }

     

       
446
       
444
       
 
       


     

       
447
       
445
       
 
       
    pub fn tracking_since(&self) -> AppResult<u64> {