herocode/herolib_rust
12
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases Wiki Activity

style: format code and reorganize imports across rfsclient codebase

Browse Source
This commit is contained in:
Sameh Abouel-saad
2025-08-28 03:50:07 +03:00
parent e114404ca7
commit b2fc0976bd
11 changed files with 795 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files

253
packages/clients/rfsclient/src/client.rs
View File

@@ -1,24 +1,23 @@
use bytes::Bytes;
use std::collections::HashMap;
use std::path::Path;
use std::sync::Arc;
use std::collections::HashMap;
use bytes::Bytes;
use openapi::{
apis::{
authentication_api, block_management_api, flist_management_api,
file_management_api, system_api, website_serving_api,
configuration::Configuration,
authentication_api, block_management_api, configuration::Configuration,
file_management_api, flist_management_api, system_api, website_serving_api,
Error as OpenApiError,
},
models::{
SignInBody, ListBlocksParams,
VerifyBlocksRequest, VerifyBlocksResponse, FlistBody, UserBlocksResponse, BlockDownloadsResponse,
BlocksResponse, PreviewResponse, FileInfo, FlistState, FlistStateResponse,
BlockDownloadsResponse, BlocksResponse, FileInfo, FlistBody, FlistState,
FlistStateResponse, ListBlocksParams, PreviewResponse, SignInBody, UserBlocksResponse,
VerifyBlocksRequest, VerifyBlocksResponse,
},
};
use crate::error::{RfsError, Result, map_openapi_error};
use crate::types::{ClientConfig, UploadOptions, DownloadOptions, FlistOptions, WaitOptions};
use crate::error::{map_openapi_error, Result, RfsError};
use crate::types::{ClientConfig, DownloadOptions, FlistOptions, UploadOptions, WaitOptions};
/// Main client for interacting with the RFS server
#[derive(Clone)]
@@ -33,16 +32,18 @@ impl RfsClient {
pub fn new(client_config: ClientConfig) -> Self {
// Create a custom reqwest client with timeout configuration
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(client_config.timeout_seconds))
.timeout(std::time::Duration::from_secs(
client_config.timeout_seconds,
))
.build()
.unwrap_or_default();
// Create OpenAPI configuration with our custom client
let mut config = Configuration::new();
config.base_path = client_config.base_url.clone();
config.user_agent = Some(format!("rfs-client/0.1.0"));
config.user_agent = Some("rfs-client/0.1.0".to_string());
config.client = client;
Self {
config: Arc::new(config),
client_config,
@@ -70,22 +71,26 @@ impl RfsClient {
if let Some(token) = Some(result.access_token) {
// Create a custom reqwest client with timeout configuration
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(self.client_config.timeout_seconds))
.timeout(std::time::Duration::from_secs(
self.client_config.timeout_seconds,
))
.build()
.unwrap_or_default();
// Create a new configuration with the auth token and timeout
let mut new_config = Configuration::new();
new_config.base_path = self.client_config.base_url.clone();
new_config.user_agent = Some(format!("rfs-client/0.1.0"));
new_config.user_agent = Some("rfs-client/0.1.0".to_string());
new_config.bearer_access_token = Some(token.clone());
new_config.client = client;
self.config = Arc::new(new_config);
self.auth_token = Some(token);
Ok(())
} else {
Err(RfsError::AuthError("No token received from server".to_string()))
Err(RfsError::AuthError(
"No token received from server".to_string(),
))
}
} else {
Err(RfsError::AuthError("No credentials provided".to_string()))
@@ -102,62 +107,79 @@ impl RfsClient {
let result = system_api::health_check_handler(&self.config)
.await
.map_err(map_openapi_error)?;
Ok(result.msg)
}
/// Upload a file to the RFS server
pub async fn upload_file<P: AsRef<Path>>(&self, file_path: P, options: Option<UploadOptions>) -> Result<String> {
pub async fn upload_file<P: AsRef<Path>>(
&self,
file_path: P,
options: Option<UploadOptions>,
) -> Result<String> {
let file_path = file_path.as_ref();
let _options = options.unwrap_or_default();
// Check if file exists
if !file_path.exists() {
return Err(RfsError::FileSystemError(format!("File not found: {}", file_path.display())));
return Err(RfsError::FileSystemError(format!(
"File not found: {}",
file_path.display()
)));
}
// Use the OpenAPI client to upload the file
let result = file_management_api::upload_file_handler(&self.config, file_path.to_path_buf())
.await
.map_err(map_openapi_error)?;
let result =
file_management_api::upload_file_handler(&self.config, file_path.to_path_buf())
.await
.map_err(map_openapi_error)?;
// Extract the file hash from the response
Ok(result.file_hash.clone())
}
/// Download a file from the RFS server
pub async fn download_file<P: AsRef<Path>>(&self, file_id: &str, output_path: P, options: Option<DownloadOptions>) -> Result<()> {
pub async fn download_file<P: AsRef<Path>>(
&self,
file_id: &str,
output_path: P,
options: Option<DownloadOptions>,
) -> Result<()> {
let output_path = output_path.as_ref();
let _options = options.unwrap_or_default();
// Create parent directories if needed
if let Some(parent) = output_path.parent() {
std::fs::create_dir_all(parent)
.map_err(|e| RfsError::FileSystemError(format!("Failed to create directory: {}", e)))?;
std::fs::create_dir_all(parent).map_err(|e| {
RfsError::FileSystemError(format!("Failed to create directory: {}", e))
})?;
}
// Create a FileDownloadRequest with the filename from the output path
let file_name = output_path.file_name()
let file_name = output_path
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("downloaded_file")
.to_string();
let download_request = openapi::models::FileDownloadRequest::new(file_name);
// Download the file
let response = file_management_api::get_file_handler(&self.config, file_id, download_request)
.await
.map_err(map_openapi_error)?;
let response =
file_management_api::get_file_handler(&self.config, file_id, download_request)
.await
.map_err(map_openapi_error)?;
// Read the response body
let bytes = response.bytes()
let bytes = response
.bytes()
.await
.map_err(|e| RfsError::RequestError(e))?;
.map_err(RfsError::RequestError)?;
// Write the file to disk
std::fs::write(output_path, bytes)
.map_err(|e| RfsError::FileSystemError(format!("Failed to write file: {}", e)))?;
Ok(())
}
@@ -168,29 +190,38 @@ impl RfsClient {
let result = block_management_api::list_blocks_handler(&self.config, page, per_page)
.await
.map_err(map_openapi_error)?;
Ok(result.blocks)
}
/// Verify blocks
pub async fn verify_blocks(&self, request: VerifyBlocksRequest) -> Result<VerifyBlocksResponse> {
pub async fn verify_blocks(
&self,
request: VerifyBlocksRequest,
) -> Result<VerifyBlocksResponse> {
let result = block_management_api::verify_blocks_handler(&self.config, request)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
/// Create a new FList from a Docker image
pub async fn create_flist(&self, image_name: &str, options: Option<FlistOptions>) -> Result<String> {
pub async fn create_flist(
&self,
image_name: &str,
options: Option<FlistOptions>,
) -> Result<String> {
// Ensure the client is authenticated
if !self.is_authenticated() {
return Err(RfsError::AuthError("Authentication required for creating FLists".to_string()));
return Err(RfsError::AuthError(
"Authentication required for creating FLists".to_string(),
));
}
// Create FList body with the required fields
let mut flist = FlistBody::new(image_name.to_string());
// Apply options if provided
if let Some(opts) = options {
flist.username = opts.username.map(Some);
@@ -201,12 +232,12 @@ impl RfsClient {
flist.identity_token = opts.identity_token.map(Some);
flist.registry_token = opts.registry_token.map(Some);
}
// Call the API to create the FList
let result = flist_management_api::create_flist_handler(&self.config, flist)
.await
.map_err(map_openapi_error)?;
// Return the job ID
Ok(result.id)
}
@@ -215,66 +246,80 @@ impl RfsClient {
pub async fn get_flist_state(&self, job_id: &str) -> Result<FlistStateResponse> {
// Ensure the client is authenticated
if !self.is_authenticated() {
return Err(RfsError::AuthError("Authentication required for accessing FList state".to_string()));
return Err(RfsError::AuthError(
"Authentication required for accessing FList state".to_string(),
));
}
// Call the API to get the FList state
let result = flist_management_api::get_flist_state_handler(&self.config, job_id)
.await
.await
.map_err(map_openapi_error)?;
Ok(result)
}
/// Wait for an FList to be created
///
///
/// This method polls the FList state until it reaches a terminal state (Created or Failed)
/// or until the timeout is reached.
pub async fn wait_for_flist_creation(&self, job_id: &str, options: Option<WaitOptions>) -> Result<FlistStateResponse> {
pub async fn wait_for_flist_creation(
&self,
job_id: &str,
options: Option<WaitOptions>,
) -> Result<FlistStateResponse> {
let options = options.unwrap_or_default();
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(options.timeout_seconds);
let deadline =
std::time::Instant::now() + std::time::Duration::from_secs(options.timeout_seconds);
loop {
// Check if we've exceeded the timeout
if std::time::Instant::now() > deadline {
return Err(RfsError::TimeoutError(format!(
"Timed out waiting for FList creation after {} seconds",
"Timed out waiting for FList creation after {} seconds",
options.timeout_seconds
)));
}
// Get the current state
let state_result = self.get_flist_state(job_id).await;
match state_result {
Ok(state) => {
// Call progress callback if provided
if let Some(ref callback) = options.progress_callback {
callback(state.flist_state.as_ref());
}
// Check if we've reached a terminal state
match state.flist_state.as_ref() {
FlistState::FlistStateCreated(_) => {
// Success! FList was created
return Ok(state);
},
}
FlistState::FlistStateFailed(error_msg) => {
// Failure! FList creation failed
return Err(RfsError::FListError(format!("FList creation failed: {}", error_msg)));
},
return Err(RfsError::FListError(format!(
"FList creation failed: {}",
error_msg
)));
}
_ => {
// Still in progress, continue polling
tokio::time::sleep(std::time::Duration::from_millis(options.poll_interval_ms)).await;
tokio::time::sleep(std::time::Duration::from_millis(
options.poll_interval_ms,
))
.await;
}
}
},
}
Err(e) => {
// If we get a 404 error, it might be because the FList job is still initializing
// Just wait and retry
println!("Warning: Error checking FList state: {}", e);
println!("Retrying in {} ms...", options.poll_interval_ms);
tokio::time::sleep(std::time::Duration::from_millis(options.poll_interval_ms)).await;
tokio::time::sleep(std::time::Duration::from_millis(options.poll_interval_ms))
.await;
}
}
}
@@ -294,7 +339,7 @@ impl RfsClient {
let result = block_management_api::get_block_downloads_handler(&self.config, hash)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
@@ -303,10 +348,12 @@ impl RfsClient {
let response = block_management_api::get_block_handler(&self.config, hash)
.await
.map_err(map_openapi_error)?;
let bytes = response.bytes().await
.map_err(|e| RfsError::RequestError(e))?;
let bytes = response
.bytes()
.await
.map_err(RfsError::RequestError)?;
Ok(bytes)
}
@@ -315,16 +362,20 @@ impl RfsClient {
let result = block_management_api::get_blocks_by_hash_handler(&self.config, hash)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
/// Get blocks uploaded by the current user
pub async fn get_user_blocks(&self, page: Option<i32>, per_page: Option<i32>) -> Result<UserBlocksResponse> {
pub async fn get_user_blocks(
&self,
page: Option<i32>,
per_page: Option<i32>,
) -> Result<UserBlocksResponse> {
let result = block_management_api::get_user_blocks_handler(&self.config, page, per_page)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
@@ -333,11 +384,12 @@ impl RfsClient {
// Create a temporary file to hold the block data
let temp_dir = std::env::temp_dir();
let temp_file_path = temp_dir.join(format!("{}-{}", file_hash, idx));
// Write the data to the temporary file
std::fs::write(&temp_file_path, &data)
.map_err(|e| RfsError::FileSystemError(format!("Failed to write temporary block file: {}", e)))?;
std::fs::write(&temp_file_path, &data).map_err(|e| {
RfsError::FileSystemError(format!("Failed to write temporary block file: {}", e))
})?;
// Upload the block
let result = block_management_api::upload_block_handler(
&self.config,
@@ -347,12 +399,12 @@ impl RfsClient {
)
.await
.map_err(map_openapi_error)?;
// Clean up the temporary file
if let Err(e) = std::fs::remove_file(temp_file_path) {
eprintln!("Warning: Failed to remove temporary block file: {}", e);
}
// Return the hash from the response
Ok(result.hash)
}
@@ -362,7 +414,7 @@ impl RfsClient {
let result = flist_management_api::list_flists_handler(&self.config)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
@@ -371,7 +423,7 @@ impl RfsClient {
let result = flist_management_api::preview_flist_handler(&self.config, flist_path)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
@@ -380,7 +432,7 @@ impl RfsClient {
let result = website_serving_api::serve_website_handler(&self.config, website_id, path)
.await
.map_err(map_openapi_error)?;
Ok(result)
}
@@ -389,25 +441,30 @@ impl RfsClient {
let result = system_api::health_check_handler(&self.config)
.await
.map_err(map_openapi_error)?;
Ok(result.msg)
}
/// Download an FList file
///
///
/// This method downloads an FList from the server and saves it to the specified path.
pub async fn download_flist<P: AsRef<Path>>(&self, flist_path: &str, output_path: P) -> Result<()> {
pub async fn download_flist<P: AsRef<Path>>(
&self,
flist_path: &str,
output_path: P,
) -> Result<()> {
let response = flist_management_api::serve_flists(&self.config, flist_path)
.await
.map_err(map_openapi_error)?;
let bytes = response.bytes().await
.map_err(|e| RfsError::RequestError(e))?;
let bytes = response
.bytes()
.await
.map_err(RfsError::RequestError)?;
std::fs::write(output_path, &bytes)
.map_err(|e| RfsError::FileSystemError(e.to_string()))?;
Ok(())
}
}

153
packages/clients/rfsclient/src/diff.rs Normal file
View File

@@ -0,0 +1,153 @@
diff --git a/packages/clients/rfsclient/src/rhai.rs b/packages/clients/rfsclient/src/rhai.rs
index fd686ba..b19c50f 100644
--- a/packages/clients/rfsclient/src/rhai.rs
+++ b/packages/clients/rfsclient/src/rhai.rs
@@ -17,6 +17,14 @@ lazy_static! {
static ref RUNTIME: Mutex<Option<Runtime>> = Mutex::new(None);
}
+/// Overload: list blocks with explicit pagination integers
+fn rfs_list_blocks_with_pagination(
+ page: rhai::INT,
+ per_page: rhai::INT,
+) -> Result<String, Box<EvalAltResult>> {
+ rfs_list_blocks(Some(page), Some(per_page))
+}
+
/// Wrapper around RfsClient to make it thread-safe for global usage
struct RfsClientWrapper {
client: Mutex<RfsClient>,
@@ -47,6 +55,8 @@ pub fn register_rfs_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>
// Register block management functions
engine.register_fn("rfs_list_blocks", rfs_list_blocks);
+ // Overload accepting explicit integer pagination params
+ engine.register_fn("rfs_list_blocks", rfs_list_blocks_with_pagination);
engine.register_fn("rfs_upload_block", rfs_upload_block);
engine.register_fn("rfs_check_block", rfs_check_block);
engine.register_fn("rfs_get_block_downloads", rfs_get_block_downloads);
diff --git a/packages/clients/rfsclient/tests/rhai_integration_tests.rs b/packages/clients/rfsclient/tests/rhai_integration_tests.rs
index 2c90001..cc38f4a 100644
--- a/packages/clients/rfsclient/tests/rhai_integration_tests.rs
+++ b/packages/clients/rfsclient/tests/rhai_integration_tests.rs
@@ -114,8 +114,7 @@ fn test_rfs_flist_management_integration() {
Err(e) => {
let error_msg = e.to_string();
println!("FList preview error: {}", error_msg);
-
- // Check if it's an authentication error (shouldn't happen with valid creds)
+ // Authentication should not fail in this integration test
if error_msg.contains("Authentication") {
panic!("❌ Authentication should work with valid credentials: {}", error_msg);
} else {
@@ -141,6 +140,7 @@ fn test_rfs_create_flist_integration() {
let create_script = format!(r#"
rfs_create_client("{}", "{}", "{}", 30);
rfs_authenticate();
+ if !rfs_is_authenticated() {{ throw "Not authenticated after rfs_authenticate()"; }}
rfs_create_flist("busybox:latest", "docker.io", "", "")
"#, TEST_SERVER_URL, TEST_USERNAME, TEST_PASSWORD);
@@ -466,10 +466,10 @@ fn test_rfs_list_blocks_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let result: bool = engine.eval(&create_script)?;
assert!(result, "Failed to create RFS client");
- // Test listing blocks with default pagination - using optional parameters
+ // Test listing blocks with explicit pagination parameters
let list_script = r#"
- let result = rfs_list_blocks();
- if typeof(result) != "string" {
+ let result = rfs_list_blocks(1, 50);
+ if result.type_of() != "string" {
throw "Expected string result ";
}
true
@@ -506,7 +506,7 @@ fn test_rfs_download_block_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let download_script = format!(
r#"
let result = rfs_download_block("test_block_hash", '{}', false);
- if typeof(result) != "string" {{
+ if result.type_of() != "string" {{
throw "Expected string result";
}}
true
@@ -540,9 +540,9 @@ fn test_rfs_verify_blocks_wrapper() -> Result<(), Box<dyn std::error::Error>> {
// Test verifying blocks with a test hash
let verify_script = r#"
- let hashes = '["test_block_hash"]';
+ let hashes = "[\"test_block_hash\"]";
let result = rfs_verify_blocks(hashes);
- if typeof(result) != "string" {
+ if result.type_of() != "string" {
throw "Expected string result";
}
true
@@ -574,16 +574,29 @@ fn test_rfs_get_block_info_wrapper() -> Result<(), Box<dyn std::error::Error>> {
// Test getting block info with a test hash
let info_script = r#"
let result = rfs_get_blocks_by_hash("test_block_hash");
- if typeof(result) != "string" {
+ if result.type_of() != "string" {
throw "Expected string result";
}
true
"#;
- let result: bool = engine.eval(info_script)?;
- assert!(result, "Failed to get block info");
-
- Ok(())
+ match engine.eval::<bool>(info_script) {
+ Ok(result) => {
+ assert!(result, "Failed to get block info");
+ Ok(())
+ }
+ Err(e) => {
+ let error_msg = e.to_string();
+ println!("Block info error (may be expected): {}", error_msg);
+ assert!(
+ error_msg.contains("404") ||
+ error_msg.contains("not found") ||
+ error_msg.contains("OpenAPI") ||
+ error_msg.contains("RFS error")
+ );
+ Ok(())
+ }
+ }
}
// =============================================================================
@@ -614,10 +627,10 @@ fn test_rfs_download_file_wrapper() -> Result<(), Box<dyn std::error::Error>> {
// Test downloading a file (assuming test file hash exists)
let download_script = format!(
r#"
- let options = #{{ verify: false }};
- let result = rfs_download_file("test_file_hash", '{}', options);
- if typeof(result) != "string" {{
- throw "Expected string result";
+ // rfs_download_file returns unit and throws on error
+ let result = rfs_download_file("test_file_hash", '{}', false);
+ if result.type_of() != "()" {{
+ throw "Expected unit return";
}}
true
"#,
@@ -839,7 +852,7 @@ fn test_rfs_download_flist_wrapper() -> Result<(), Box<dyn std::error::Error>> {
let download_script = format!(
r#"
let result = rfs_download_flist("flists/test/test.fl", '{}');
- if typeof(result) != "string" {{
+ if result.type_of() != "string" {{
throw "Expected string result";
}}
true
@@ -874,7 +887,7 @@ fn test_rfs_wait_for_flist_creation_wrapper() -> Result<(), Box<dyn std::error::
// Test waiting for FList creation with a test job ID
let wait_script = r#"
let result = rfs_wait_for_flist_creation("test_job_id", 10, 1000);
- if typeof(result) != "string" {
+ if result.type_of() != "string" {
throw "Expected string result";
}
true

2
packages/clients/rfsclient/src/lib.rs
View File

@@ -3,8 +3,8 @@
pub mod client;
pub mod error;
pub mod types;
pub mod rhai;
pub mod types;
pub use client::RfsClient;
pub use error::RfsError;

222
packages/clients/rfsclient/src/rhai.rs
View File

@@ -24,7 +24,9 @@ struct RfsClientWrapper {
impl RfsClientWrapper {
fn new(client: RfsClient) -> Self {
Self { client: Mutex::new(client) }
Self {
client: Mutex::new(client),
}
}
}
@@ -44,7 +46,7 @@ pub fn register_rfs_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>
engine.register_fn("rfs_get_system_info", rfs_get_system_info);
engine.register_fn("rfs_is_authenticated", rfs_is_authenticated);
engine.register_fn("rfs_health_check", rfs_health_check);
// Register block management functions
engine.register_fn("rfs_list_blocks", rfs_list_blocks);
engine.register_fn("rfs_list_blocks", rfs_list_blocks);
@@ -55,11 +57,11 @@ pub fn register_rfs_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>
engine.register_fn("rfs_get_block", rfs_get_block);
engine.register_fn("rfs_get_blocks_by_hash", rfs_get_blocks_by_hash);
engine.register_fn("rfs_get_user_blocks", rfs_get_user_blocks);
// Register file operations functions
engine.register_fn("rfs_upload_file", rfs_upload_file);
engine.register_fn("rfs_download_file", rfs_download_file);
// Register FList management functions
engine.register_fn("rfs_create_flist", rfs_create_flist);
engine.register_fn("rfs_list_flists", rfs_list_flists);
@@ -67,10 +69,10 @@ pub fn register_rfs_module(engine: &mut Engine) -> Result<(), Box<EvalAltResult>
engine.register_fn("rfs_preview_flist", rfs_preview_flist);
engine.register_fn("rfs_download_flist", rfs_download_flist);
engine.register_fn("rfs_wait_for_flist_creation", rfs_wait_for_flist_creation);
// Register Website functions
engine.register_fn("rfs_get_website", rfs_get_website);
// Register System and Utility functions
engine.register_fn("rfs_is_authenticated", rfs_is_authenticated);
engine.register_fn("rfs_health_check", rfs_health_check);
@@ -250,7 +252,7 @@ pub fn rfs_authenticate() -> Result<bool, Box<EvalAltResult>> {
}
/// Check if the client is authenticated with the RFS server
///
///
/// # Returns
/// `true` if authenticated, `false` otherwise
fn rfs_is_authenticated() -> Result<bool, Box<EvalAltResult>> {
@@ -261,7 +263,7 @@ fn rfs_is_authenticated() -> Result<bool, Box<EvalAltResult>> {
rhai::Position::NONE,
))
})?;
Ok(client.is_authenticated())
}
@@ -300,7 +302,7 @@ pub fn rfs_get_system_info() -> Result<String, Box<EvalAltResult>> {
}
/// Check the health status of the RFS server
///
///
/// # Returns
/// The health status as a string
fn rfs_health_check() -> Result<String, Box<EvalAltResult>> {
@@ -321,10 +323,8 @@ fn rfs_health_check() -> Result<String, Box<EvalAltResult>> {
))
})?;
let result = runtime.block_on(async {
client.health_check().await
});
let result = runtime.block_on(async { client.health_check().await });
result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Health check failed: {}", e).into(),
@@ -338,11 +338,11 @@ fn rfs_health_check() -> Result<String, Box<EvalAltResult>> {
// =============================================================================
/// List all blocks with optional filtering
///
///
/// # Arguments
/// * `page` - Optional page number (1-based)
/// * `per_page` - Optional number of items per page
///
///
/// # Returns
/// JSON string containing block information
fn rfs_list_blocks_impl(
@@ -368,20 +368,18 @@ fn rfs_list_blocks_impl(
// Create ListBlocksParams with optional page and per_page
let mut params = openapi::models::ListBlocksParams::new();
// Convert Rhai INT to i32 for the API and set the parameters
if let Some(p) = page.and_then(|p| p.try_into().ok()) {
params.page = Some(Some(p));
}
if let Some(pp) = per_page.and_then(|p| p.try_into().ok()) {
params.per_page = Some(Some(pp));
}
let result = runtime.block_on(async {
client.list_blocks(Some(params)).await
});
let result = runtime.block_on(async { client.list_blocks(Some(params)).await });
match result {
Ok(blocks) => {
// Convert blocks to JSON string for Rhai
@@ -400,10 +398,10 @@ fn rfs_list_blocks_impl(
}
/// Check if a block exists
///
///
/// # Arguments
/// * `hash` - The hash of the block to check
///
///
/// # Returns
/// `true` if the block exists, `false` otherwise
fn rfs_check_block(hash: &str) -> Result<bool, Box<EvalAltResult>> {
@@ -424,10 +422,8 @@ fn rfs_check_block(hash: &str) -> Result<bool, Box<EvalAltResult>> {
))
})?;
let result = runtime.block_on(async {
client.check_block(hash).await
});
let result = runtime.block_on(async { client.check_block(hash).await });
result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to check block: {}", e).into(),
@@ -437,10 +433,10 @@ fn rfs_check_block(hash: &str) -> Result<bool, Box<EvalAltResult>> {
}
/// Get block download statistics
///
///
/// # Arguments
/// * `hash` - The hash of the block
///
///
/// # Returns
/// JSON string containing download statistics
fn rfs_get_block_downloads(hash: &str) -> Result<String, Box<EvalAltResult>> {
@@ -461,10 +457,8 @@ fn rfs_get_block_downloads(hash: &str) -> Result<String, Box<EvalAltResult>> {
))
})?;
let result = runtime.block_on(async {
client.get_block_downloads(hash).await
});
let result = runtime.block_on(async { client.get_block_downloads(hash).await });
match result {
Ok(stats) => {
// Convert stats to JSON string for Rhai
@@ -483,10 +477,10 @@ fn rfs_get_block_downloads(hash: &str) -> Result<String, Box<EvalAltResult>> {
}
/// Verify blocks
///
///
/// # Arguments
/// * `hashes` - JSON array of block hashes to verify
///
///
/// # Returns
/// JSON string containing verification results
fn rfs_verify_blocks(hashes: &str) -> Result<String, Box<EvalAltResult>> {
@@ -525,16 +519,14 @@ fn rfs_verify_blocks(hashes: &str) -> Result<String, Box<EvalAltResult>> {
.into_iter()
.map(|block_hash| openapi::models::VerifyBlock {
block_hash: block_hash.clone(),
block_index: 0, // Default to 0 if not specified
file_hash: block_hash, // Using the same hash as file_hash for now
block_index: 0, // Default to 0 if not specified
file_hash: block_hash, // Using the same hash as file_hash for now
})
.collect();
let request = openapi::models::VerifyBlocksRequest::new(verify_blocks);
let result = runtime.block_on(async {
client.verify_blocks(request).await
});
let result = runtime.block_on(async { client.verify_blocks(request).await });
match result {
Ok(verification) => {
// Convert verification to JSON string for Rhai
@@ -553,10 +545,10 @@ fn rfs_verify_blocks(hashes: &str) -> Result<String, Box<EvalAltResult>> {
}
/// Get a block by hash
///
///
/// # Arguments
/// * `hash` - The hash of the block to retrieve
///
///
/// # Returns
/// The block data as a byte array
fn rfs_get_block(hash: &str) -> Result<rhai::Blob, Box<EvalAltResult>> {
@@ -577,12 +569,10 @@ fn rfs_get_block(hash: &str) -> Result<rhai::Blob, Box<EvalAltResult>> {
))
})?;
let result = runtime.block_on(async {
client.get_block(hash).await
});
let result = runtime.block_on(async { client.get_block(hash).await });
match result {
Ok(bytes) => Ok(bytes.to_vec().into()),
Ok(bytes) => Ok(bytes.to_vec()),
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to get block: {}", e).into(),
rhai::Position::NONE,
@@ -591,10 +581,10 @@ fn rfs_get_block(hash: &str) -> Result<rhai::Blob, Box<EvalAltResult>> {
}
/// Get blocks by file hash or block hash
///
///
/// # Arguments
/// * `hash` - The file hash or block hash to look up
///
///
/// # Returns
/// JSON string containing block information
fn rfs_get_blocks_by_hash(hash: &str) -> Result<String, Box<EvalAltResult>> {
@@ -615,10 +605,8 @@ fn rfs_get_blocks_by_hash(hash: &str) -> Result<String, Box<EvalAltResult>> {
))
})?;
let result = runtime.block_on(async {
client.get_blocks_by_hash(hash).await
});
let result = runtime.block_on(async { client.get_blocks_by_hash(hash).await });
match result {
Ok(blocks) => {
// Convert blocks to JSON string for Rhai
@@ -637,11 +625,11 @@ fn rfs_get_blocks_by_hash(hash: &str) -> Result<String, Box<EvalAltResult>> {
}
/// Get blocks uploaded by the current user
///
///
/// # Arguments
/// * `page` - Optional page number (1-based)
/// * `per_page` - Optional number of items per page
///
///
/// # Returns
/// JSON string containing user's blocks information
fn rfs_get_user_blocks_impl(
@@ -669,10 +657,8 @@ fn rfs_get_user_blocks_impl(
let page_i32 = page.and_then(|p| p.try_into().ok());
let per_page_i32 = per_page.and_then(|p| p.try_into().ok());
let result = runtime.block_on(async {
client.get_user_blocks(page_i32, per_page_i32).await
});
let result = runtime.block_on(async { client.get_user_blocks(page_i32, per_page_i32).await });
match result {
Ok(user_blocks) => {
// Convert user blocks to JSON string for Rhai
@@ -691,15 +677,19 @@ fn rfs_get_user_blocks_impl(
}
/// Upload a block to the RFS server
///
///
/// # Arguments
/// * `file_hash` - The hash of the file this block belongs to
/// * `index` - The index of the block in the file
/// * `data` - The block data as a byte array
///
///
/// # Returns
/// The hash of the uploaded block
fn rfs_upload_block(file_hash: &str, index: rhai::INT, data: rhai::Blob) -> Result<String, Box<EvalAltResult>> {
fn rfs_upload_block(
file_hash: &str,
index: rhai::INT,
data: rhai::Blob,
) -> Result<String, Box<EvalAltResult>> {
let runtime_mutex = get_runtime()?;
let runtime_guard = runtime_mutex.lock().map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
@@ -718,15 +708,14 @@ fn rfs_upload_block(file_hash: &str, index: rhai::INT, data: rhai::Blob) -> Resu
})?;
// Convert index to i64 for the API
let index_i64 = index as i64;
let index_i64 = index;
// Convert the blob to Vec<u8>
let data_vec = data.to_vec();
let result = runtime.block_on(async {
client.upload_block(file_hash, index_i64, data_vec).await
});
let result =
runtime.block_on(async { client.upload_block(file_hash, index_i64, data_vec).await });
result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to upload block: {}", e).into(),
@@ -747,7 +736,6 @@ fn rfs_get_user_blocks(params: Map) -> Result<String, Box<EvalAltResult>> {
rfs_get_user_blocks_impl(page, per_page)
}
/// Rhai-facing adapter: accept params map with optional keys: page, per_page
fn rfs_list_blocks(params: Map) -> Result<String, Box<EvalAltResult>> {
// Extract optional page and per_page from the map
@@ -776,7 +764,11 @@ fn rfs_list_blocks(params: Map) -> Result<String, Box<EvalAltResult>> {
/// # Returns
///
/// * `Result<(), Box<EvalAltResult>>` - Ok(()) if download was successful, error otherwise
fn rfs_download_file(file_id: &str, output_path: &str, verify: bool) -> Result<(), Box<EvalAltResult>> {
fn rfs_download_file(
file_id: &str,
output_path: &str,
verify: bool,
) -> Result<(), Box<EvalAltResult>> {
let runtime_mutex = get_runtime()?;
let runtime_guard = runtime_mutex.lock().map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
@@ -795,8 +787,10 @@ fn rfs_download_file(file_id: &str, output_path: &str, verify: bool) -> Result<(
})?;
let download_options = Some(DownloadOptions { verify });
let result = runtime.block_on(async {
client.download_file(file_id, output_path, download_options).await
let result = runtime.block_on(async {
client
.download_file(file_id, output_path, download_options)
.await
});
result.map_err(|e| {
@@ -818,7 +812,11 @@ fn rfs_download_file(file_id: &str, output_path: &str, verify: bool) -> Result<(
/// # Returns
///
/// * `Result<String, Box<EvalAltResult>>` - File ID of the uploaded file
pub fn rfs_upload_file(file_path: &str, chunk_size: rhai::INT, verify: bool) -> Result<String, Box<EvalAltResult>> {
pub fn rfs_upload_file(
file_path: &str,
chunk_size: rhai::INT,
verify: bool,
) -> Result<String, Box<EvalAltResult>> {
let runtime_mutex = get_runtime()?;
let runtime_guard = runtime_mutex.lock().map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
@@ -838,7 +836,11 @@ pub fn rfs_upload_file(file_path: &str, chunk_size: rhai::INT, verify: bool) ->
})?;
let upload_options = Some(UploadOptions {
chunk_size: if chunk_size > 0 { Some(chunk_size as usize) } else { None },
chunk_size: if chunk_size > 0 {
Some(chunk_size as usize)
} else {
None
},
verify,
});
@@ -857,11 +859,11 @@ pub fn rfs_upload_file(file_path: &str, chunk_size: rhai::INT, verify: bool) ->
// =============================================================================
/// Get website content from the RFS server
///
///
/// # Arguments
/// * `website_id` - The ID of the website
/// * `path` - The path to the content within the website
///
///
/// # Returns
/// The website content as a string
fn rfs_get_website(website_id: &str, path: &str) -> Result<String, Box<EvalAltResult>> {
@@ -882,11 +884,14 @@ fn rfs_get_website(website_id: &str, path: &str) -> Result<String, Box<EvalAltRe
))
})?;
let result = runtime.block_on(async {
let result = runtime.block_on(async {
let response = client.get_website(website_id, path).await?;
response.text().await.map_err(|e| RfsError::RequestError(e.into()))
response
.text()
.await
.map_err(RfsError::RequestError)
});
result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("Failed to get website content: {}", e).into(),
@@ -900,13 +905,13 @@ fn rfs_get_website(website_id: &str, path: &str) -> Result<String, Box<EvalAltRe
// =============================================================================
/// Create an FList from a Docker image
///
///
/// # Arguments
/// * `image_name` - Docker image name (e.g., "ubuntu:20.04")
/// * `server_address` - Optional server address (empty string if not needed)
/// * `identity_token` - Optional identity token (empty string if not needed)
/// * `registry_token` - Optional registry token (empty string if not needed)
///
///
/// # Returns
/// Job ID for tracking FList creation progress
fn rfs_create_flist(
@@ -932,7 +937,7 @@ fn rfs_create_flist(
rhai::Position::NONE,
))
})?;
// Build FList options
let mut options = crate::types::FlistOptions::default();
if !server_address.is_empty() {
@@ -944,9 +949,9 @@ fn rfs_create_flist(
if !registry_token.is_empty() {
options.registry_token = Some(registry_token.to_string());
}
let result = runtime.block_on(async { client.create_flist(image_name, Some(options)).await });
result.map_err(|e| {
Box::new(EvalAltResult::ErrorRuntime(
format!("FList creation failed: {}", e).into(),
@@ -956,7 +961,7 @@ fn rfs_create_flist(
}
/// List all available FLists
///
///
/// # Returns
/// JSON string containing FList information
fn rfs_list_flists() -> Result<String, Box<EvalAltResult>> {
@@ -977,9 +982,9 @@ fn rfs_list_flists() -> Result<String, Box<EvalAltResult>> {
rhai::Position::NONE,
))
})?;
let result = runtime.block_on(async { client.list_flists().await });
match result {
Ok(flists) => {
// Convert HashMap to JSON string for Rhai
@@ -998,10 +1003,10 @@ fn rfs_list_flists() -> Result<String, Box<EvalAltResult>> {
}
/// Get FList creation state by job ID
///
///
/// # Arguments
/// * `job_id` - Job ID returned from create_flist
///
///
/// # Returns
/// JSON string containing FList state information
fn rfs_get_flist_state(job_id: &str) -> Result<String, Box<EvalAltResult>> {
@@ -1022,9 +1027,9 @@ fn rfs_get_flist_state(job_id: &str) -> Result<String, Box<EvalAltResult>> {
rhai::Position::NONE,
))
})?;
let result = runtime.block_on(async { client.get_flist_state(job_id).await });
match result {
Ok(state) => {
// Convert state to JSON string for Rhai
@@ -1043,10 +1048,10 @@ fn rfs_get_flist_state(job_id: &str) -> Result<String, Box<EvalAltResult>> {
}
/// Preview an FList's contents
///
///
/// # Arguments
/// * `flist_path` - Path to the FList
///
///
/// # Returns
/// JSON string containing FList preview information
fn rfs_preview_flist(flist_path: &str) -> Result<String, Box<EvalAltResult>> {
@@ -1067,9 +1072,9 @@ fn rfs_preview_flist(flist_path: &str) -> Result<String, Box<EvalAltResult>> {
rhai::Position::NONE,
))
})?;
let result = runtime.block_on(async { client.preview_flist(flist_path).await });
match result {
Ok(preview) => {
// Convert preview to JSON string for Rhai
@@ -1088,11 +1093,11 @@ fn rfs_preview_flist(flist_path: &str) -> Result<String, Box<EvalAltResult>> {
}
/// Download an FList file from the RFS server
///
///
/// # Arguments
/// * `flist_path` - Path to the FList to download (e.g., "flists/user/example.fl")
/// * `output_path` - Local path where the FList will be saved
///
///
/// # Returns
/// Empty string on success, error on failure
fn rfs_download_flist(flist_path: &str, output_path: &str) -> Result<String, Box<EvalAltResult>> {
@@ -1113,10 +1118,8 @@ fn rfs_download_flist(flist_path: &str, output_path: &str) -> Result<String, Box
))
})?;
let result = runtime.block_on(async {
client.download_flist(flist_path, output_path).await
});
let result = runtime.block_on(async { client.download_flist(flist_path, output_path).await });
match result {
Ok(_) => Ok(String::new()),
Err(e) => Err(Box::new(EvalAltResult::ErrorRuntime(
@@ -1127,16 +1130,16 @@ fn rfs_download_flist(flist_path: &str, output_path: &str) -> Result<String, Box
}
/// Wait for an FList to be created
///
///
/// # Arguments
/// * `job_id` - The job ID returned by rfs_create_flist
/// * `timeout_seconds` - Maximum time to wait in seconds (default: 300)
/// * `poll_interval_ms` - Polling interval in milliseconds (default: 1000)
///
///
/// # Returns
/// JSON string containing the final FList state
fn rfs_wait_for_flist_creation_impl(
job_id: &str,
job_id: &str,
timeout_seconds: Option<rhai::INT>,
poll_interval_ms: Option<rhai::INT>,
) -> Result<String, Box<EvalAltResult>> {
@@ -1163,10 +1166,9 @@ fn rfs_wait_for_flist_creation_impl(
progress_callback: None,
};
let result = runtime.block_on(async {
client.wait_for_flist_creation(job_id, Some(options)).await
});
let result =
runtime.block_on(async { client.wait_for_flist_creation(job_id, Some(options)).await });
match result {
Ok(state) => {
// Convert state to JSON string for Rhai
@@ -1198,4 +1200,4 @@ fn rfs_wait_for_flist_creation(job_id: &str, params: Map) -> Result<String, Box<
.and_then(|d| d.clone().try_cast::<rhai::INT>());
rfs_wait_for_flist_creation_impl(job_id, timeout_seconds, poll_interval_ms)
}
}

20
packages/clients/rfsclient/src/types.rs
View File

@@ -1,8 +1,7 @@
// Re-export common types from OpenAPI client for convenience
pub use openapi::models::{
BlockDownloadsResponse, BlocksResponse, FileInfo,
FileUploadResponse, FlistBody, FlistState, Job, ListBlocksResponse,
PreviewResponse, ResponseResult, SignInResponse, VerifyBlocksResponse,
BlockDownloadsResponse, BlocksResponse, FileInfo, FileUploadResponse, FlistBody, FlistState,
Job, ListBlocksResponse, PreviewResponse, ResponseResult, SignInResponse, VerifyBlocksResponse,
};
/// Authentication credentials for the RFS server
@@ -74,10 +73,10 @@ pub struct FlistOptions {
pub struct WaitOptions {
/// Maximum time to wait in seconds
pub timeout_seconds: u64,
/// Polling interval in milliseconds
pub poll_interval_ms: u64,
/// Optional progress callback
pub progress_callback: Option<Box<dyn Fn(&FlistState) + Send + Sync>>,
}
@@ -88,7 +87,14 @@ impl std::fmt::Debug for WaitOptions {
f.debug_struct("WaitOptions")
.field("timeout_seconds", &self.timeout_seconds)
.field("poll_interval_ms", &self.poll_interval_ms)
.field("progress_callback", &if self.progress_callback.is_some() { "Some(...)" } else { "None" })
.field(
"progress_callback",
&if self.progress_callback.is_some() {
"Some(...)"
} else {
"None"
},
)
.finish()
}
}
@@ -107,7 +113,7 @@ impl Clone for WaitOptions {
impl Default for WaitOptions {
fn default() -> Self {
Self {
timeout_seconds: 300, // 5 minutes default timeout
timeout_seconds: 300, // 5 minutes default timeout
poll_interval_ms: 1000, // 1 second default polling interval
progress_callback: None,
}