Fix getBlockHeight

Author: evodevo

Cargo.lock

@@ -10,7 +10,7 @@ exclude = []
 resolver = "2"
 
 [workspace.package]
-version = "2.0.5"
+version = "2.0.6"
 authors = ["Dexterlab <support@dexterlab.com>"]
 repository = "https://github.com/solana-labs/solana"
 homepage = "https://dexterlab.com/"
@@ -75,10 +75,10 @@ solana-metrics = "=2.0.5"
 solana-net-utils = "=2.0.5"
 solana-perf = "=2.0.5"
 solana-rayon-threadlimit = "=2.0.5"
-block-meta-rpc = { path = "rpc", version = "=2.0.5" }
+block-meta-rpc = { path = "rpc", version = "=2.0.6" }
 solana-rpc-client-api = "=2.0.5"
 solana-sdk = "=2.0.5"
-solana-storage-mysql = { path = "storage-mysql", version = "=2.0.5" }
+solana-storage-mysql = { path = "storage-mysql", version = "=2.0.6" }
 solana-version = "=2.0.5"
 spl-memo = "=3.0.1"
 symlink = "0.1.0"

Cargo.toml

@@ -23,6 +23,10 @@ pub struct Config {
 
     /// MySQL database name
     pub mysql_name: String,
+
+    /// MySQL table name for blocks
+    #[serde(default = "default_mysql_table")]
+    pub mysql_table: String,
 }
 
 impl Config {
@@ -40,3 +44,7 @@ impl Config {
         }
     }
 }
+
+fn default_mysql_table() -> String {
+    "sol_mainnet_block".to_string()
+}

rpc/src/config.rs

@@ -112,6 +112,7 @@ fn main() {
 
     let mut rpc_config = JsonRpcConfig::default_for_storage_rpc();
     rpc_config.rpc_mysql_config = rpc_mysql_config;
+    rpc_config.mysql_table = app_config.mysql_table.clone();
     rpc_config.obsolete_v1_7_api = matches.is_present("obsolete_v1_7_rpc_api");
     rpc_config.rpc_threads = value_t_or_exit!(matches, "rpc_threads", usize);
     rpc_config.rpc_niceness_adj = value_t_or_exit!(matches, "rpc_niceness_adj", i8);

rpc/src/main.rs

@@ -60,6 +60,7 @@ pub struct JsonRpcConfig {
     pub full_api: bool,
     pub obsolete_v1_7_api: bool,
     pub max_request_body_size: Option<usize>,
+    pub mysql_table: String,
 }
 
 impl JsonRpcConfig {

rpc/src/request_processor.rs

@@ -85,6 +85,7 @@ impl JsonRpcService {
                     username: username.clone(),
                     password: password.clone(),
                     db_name: db_name.clone(),
+                    table_name: config.mysql_table.clone(),
                 };
                 runtime
                     .block_on(solana_storage_mysql::meta_storage::MetaStorage::new_with_config(mysql_config))

rpc/src/rpc_service.rs

@@ -81,6 +81,7 @@ pub struct MetaStorageConfig {
     pub username: String,
     pub password: String,
     pub db_name: String,
+    pub table_name: String,
 }
 
 impl Default for MetaStorageConfig {
@@ -93,13 +94,15 @@ impl Default for MetaStorageConfig {
             username: String::new(),
             password: String::new(),
             db_name: String::new(),
+            table_name: "sol_mainnet_block".to_string(),
         }
     }
 }
 
 #[derive(Clone)]
 pub struct MetaStorage {
     connection: MySQLConnection,
+    table_name: String,
 }
 
 impl MetaStorage {
@@ -124,6 +127,7 @@ impl MetaStorage {
             username,
             password,
             db_name,
+            table_name,
         } = config;
         let dsn = format!("mysql://{}:{}@{}:{}/{}", username, password, host, port, db_name);
         let connection = MySQLConnection::new(
@@ -135,6 +139,7 @@ impl MetaStorage {
 
         Ok(Self {
             connection,
+            table_name,
         })
     }
 
@@ -147,7 +152,7 @@ impl MetaStorage {
 
         // Use `get_first_key` to get the smallest slot
         let first_block: Option<u64> = mysql
-            .get_first_key("sol_mainnet_block", "id")
+            .get_first_key(&self.table_name, "id")
             .await
             .map_err(|e| Error::StorageBackendError(Box::new(e)))?;
 
@@ -162,7 +167,7 @@ impl MetaStorage {
 
         // Use `get_last_key` to get the largest slot
         let last_block: Option<u64> = mysql
-            .get_last_key("sol_mainnet_block", "id")
+            .get_last_key(&self.table_name, "id")
             .await
             .map_err(|e| Error::StorageBackendError(Box::new(e)))?;
 
@@ -187,7 +192,7 @@ impl MetaStorage {
         let limit_i64 = limit.map(|l| l as i64);
 
         let blocks: Vec<u64> = mysql
-            .get_row_keys("sol_mainnet_block", Some(&start_key), end_key.as_deref(), limit_i64)
+            .get_row_keys(&self.table_name, Some(&start_key), end_key.as_deref(), limit_i64)
             .await?;
         Ok(blocks.into_iter().map(|block| block as Slot).collect())
     }
@@ -200,7 +205,7 @@ impl MetaStorage {
 
         // Fetch `PrimitiveDateTime` directly from MySQL
         let block_time_primitive: PrimitiveDateTime = mysql
-            .get_single_value::<PrimitiveDateTime>("sol_mainnet_block", "block_time", "id", &key)
+            .get_single_value::<PrimitiveDateTime>(&self.table_name, "block_time", "id", &key)
             .await
             .map_err(|e| match e {
                 crate::mysql::Error::RowNotFound => Error::BlockNotFound(slot),
@@ -227,22 +232,47 @@ impl MetaStorage {
         let mysql = self.connection.client();
 
         // Fetch the ID of the latest block
-        let latest_block_id: u64 = mysql
-            .get_last_key("solana_blocks", "id")
+        let latest_block_id: u64 = match mysql
+            .get_last_key(&self.table_name, "id")
             .await
-            .map_err(|e| Error::StorageBackendError(Box::new(e)))?
-            .ok_or_else(|| Error::BlockNotFound(0))?; // Handle case where no blocks exist
+        {
+            Ok(Some(id)) => id,
+            Ok(None) => {
+                warn!("No rows in table '{}'; cannot determine latest block id", self.table_name);
+                return Err(Error::BlockNotFound(0));
+            }
+            Err(e) => {
+                error!("Failed to fetch latest block id from '{}': {}", self.table_name, e);
+                return Err(Error::StorageBackendError(Box::new(e)));
+            }
+        };
 
         debug!("Latest block ID fetched: {}", latest_block_id);
 
         // Fetch the block height using the latest block ID
-        let block_height: u64 = mysql
-            .get_single_value::<u64>("solana_blocks", "block_height", "id", &latest_block_id.to_string())
+        let block_height: u64 = match mysql
+            .get_single_value::<u64>(&self.table_name, "block_height", "id", &latest_block_id.to_string())
             .await
-            .map_err(|e| match e {
-                crate::mysql::Error::RowNotFound => Error::BlockNotFound(latest_block_id),
-                other => Error::StorageBackendError(Box::new(other)),
-            })?;
+        {
+            Ok(height) => height,
+            Err(crate::mysql::Error::RowNotFound) => {
+                warn!(
+                    "Block height not found for latest block id {} in '{}'",
+                    latest_block_id,
+                    self.table_name
+                );
+                return Err(Error::BlockNotFound(latest_block_id));
+            }
+            Err(other) => {
+                error!(
+                    "Failed to fetch block_height for id {} from '{}': {}",
+                    latest_block_id,
+                    self.table_name,
+                    other
+                );
+                return Err(Error::StorageBackendError(Box::new(other)));
+            }
+        };
 
         debug!("Latest block Height fetched: {}", block_height);
 

storage-mysql/src/meta_storage.rs

@@ -17,7 +17,7 @@ pub enum Error {
     #[error("Timeout")]
     Timeout,
 
-    #[error("MySQL")]
+    #[error("MySQL: {0}")]
     MySQL(mysql::Error),
 }