Line data    Source code

       1             : #include "fd_shred_cap.h"
       2             : #include <unistd.h>
       3             : #include <stdio.h>
       4             : 
       5             : /* int */
       6             : /* fd_shred_cap_mark_stable( fd_replay_t * replay, ulong slot ) { */
       7             : /*   if( replay->shred_cap == NULL ) return FD_SHRED_CAP_OK; */
       8             : 
       9             : /*   if (replay->stable_slot_start == 0) */
      10             : /*     replay->stable_slot_start = slot; */
      11             : /*   if (slot > replay->stable_slot_end) */
      12             : /*     replay->stable_slot_end = slot; */
      13             : 
      14             : /*   if (replay->stable_slot_start + MAX_STABLE_PREFIX < replay->stable_slot_end) { */
      15             : /*     FD_LOG_WARNING( ("reaching max stable prefix length (%lu..%lu more than %u slots) in shred_cap", */
      16             : /*                      replay->stable_slot_start, */
      17             : /*                      replay->stable_slot_end, */
      18             : /*                      MAX_STABLE_PREFIX) ); */
      19             : /*   } */
      20             : 
      21             : /*   return FD_SHRED_CAP_OK; */
      22             : /* } */
      23             : 
      24             : int
      25             : fd_shred_cap_archive( fd_shred_cap_ctx_t * ctx FD_PARAM_UNUSED,
      26             :                       fd_shred_t const *   shred,
      27           0 :                       uchar                flags  FD_PARAM_UNUSED) {
      28           0 :   ulong  wsz;
      29           0 :   ulong  shred_len = fd_shred_sz( shred );
      30           0 :   ushort hdr_len = sizeof( fd_shred_cap_hdr_t );
      31           0 :   fd_shred_cap_hdr_t cap_header = {.sz = shred_len, .flags = flags};
      32           0 :   fd_io_write( ctx->shred_cap_fileno, &cap_header, (ulong)hdr_len, (ulong)hdr_len, &wsz );
      33           0 :   FD_TEST( wsz == hdr_len );
      34           0 :   fd_io_write( ctx->shred_cap_fileno, shred, shred_len, shred_len, &wsz );
      35           0 :   FD_TEST( wsz == shred_len );
      36           0 :   fsync( ctx->shred_cap_fileno );
      37             : 
      38           0 :   return FD_SHRED_CAP_OK;
      39           0 : }
      40             : 
      41             : int
      42             : fd_shred_cap_replay( const char *      shred_cap_fpath,
      43           0 :                      fd_store_t *      store ) {
      44           0 :   FILE * shred_cap = fopen( shred_cap_fpath, "rb" );
      45           0 :   FD_TEST( shred_cap );
      46             : 
      47           0 :   ulong cnt = 0;
      48           0 :   for( ;; ) {
      49           0 :     fd_shred_cap_hdr_t header;
      50           0 :     ulong nshredcap_hdr = fread( &header, sizeof( fd_shred_cap_hdr_t ), 1, shred_cap );
      51           0 :     if ( nshredcap_hdr != 1 ) break;
      52             : 
      53           0 :     uchar buffer[FD_SHRED_MAX_SZ];
      54           0 :     ulong shred_len = header.sz;
      55           0 :     ulong bytes_read = fread( buffer, sizeof( uchar ), shred_len, shred_cap );
      56           0 :     if ( bytes_read != shred_len ) break;
      57             : 
      58           0 :     fd_shred_t const * shred = fd_shred_parse( buffer, shred_len );
      59           0 :     if ( fd_store_shred_insert( store, shred ) < FD_BLOCKSTORE_OK ) return FD_SHRED_CAP_ERR;
      60           0 :     cnt++;
      61             :     /*
      62             :     if ( FD_SHRED_CAP_FLAG_IS_TURBINE(header.flags) ) {
      63             :       fd_replay_turbine_rx( replay, shred, fd_shred_sz( shred ));
      64             :     } else {
      65             :       fd_replay_repair_rx( replay, shred );
      66             :     }
      67             :     */
      68           0 :   }
      69           0 :   FD_LOG_WARNING( ("Finish inserting %lu shreds from the shredcap file", cnt) );
      70           0 :   return FD_SHRED_CAP_OK;
      71           0 : }