tfgrid/projectmycelium
11
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat: add debug logging for slice calculation and node management operations

Browse Source
This commit is contained in:
mik-tf
2025-09-09 00:19:43 -04:00
parent 52316319e6
commit 31f3834e6d
19 changed files with 597 additions and 4155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
src/controllers/dashboard.rs
View File

@@ -427,6 +427,28 @@ impl DashboardController {
// Get resource provider nodes with updated slice calculations
let resource_provider_nodes = resource_provider_service.get_resource_provider_nodes(&user_email);
// DEBUG: Log template data being prepared
log::info!(
target: "debug.slice_trace",
"dashboard:template_data_prep user={} nodes_loaded_count={}",
user_email,
resource_provider_nodes.len()
);
// DEBUG: Log each node's slice data being sent to template
for node in &resource_provider_nodes {
log::info!(
target: "debug.slice_trace",
"dashboard:node_template_data user={} node_id={} grid_node_id={:?} total_base_slices={} allocated_base_slices={} available_combinations_count={}",
user_email,
node.id,
node.grid_node_id,
node.total_base_slices,
node.allocated_base_slices,
node.available_combinations.len()
);
}
// Calculate resource_provider statistics from nodes
let total_nodes = resource_provider_nodes.len() as u32;
let mut online_nodes = 0u32;
@@ -2524,6 +2546,17 @@ impl DashboardController {
pricing_mode
);
// DEBUG: Log which path will be taken
log::info!(
target: "debug.slice_trace",
"add_grid_nodes:path_decision req_id={} email={} slice_formats_count={} full_node_rental_enabled={} pricing_mode={}",
req_id,
user_email,
slice_formats.len(),
full_node_rental_enabled,
pricing_mode
);
let add_result = if !slice_formats.is_empty() || full_node_rental_enabled {
// Create rental options if full node rental is enabled
let rental_options = if full_node_rental_enabled {
@@ -2561,6 +2594,13 @@ impl DashboardController {
// Choose the appropriate method based on pricing mode
if pricing_mode == "individual" && individual_node_pricing.is_some() {
log::info!(
target: "debug.slice_trace",
"add_grid_nodes:calling_individual_pricing req_id={} email={} node_count={}",
req_id,
user_email,
node_ids.len()
);
resource_provider_service.add_multiple_grid_nodes_with_individual_pricing(
&user_email,
node_ids.clone(),
@@ -2568,6 +2608,13 @@ impl DashboardController {
individual_node_pricing.unwrap()
).await
} else {
log::info!(
target: "debug.slice_trace",
"add_grid_nodes:calling_comprehensive_config req_id={} email={} node_count={}",
req_id,
user_email,
node_ids.len()
);
resource_provider_service.add_multiple_grid_nodes_with_comprehensive_config(
&user_email,
node_ids.clone(),
@@ -2576,6 +2623,13 @@ impl DashboardController {
).await
}
} else {
log::info!(
target: "debug.slice_trace",
"add_grid_nodes:calling_simple_add req_id={} email={} node_count={}",
req_id,
user_email,
node_ids.len()
);
resource_provider_service.add_multiple_grid_nodes(&user_email, node_ids.clone()).await
};

136
src/services/resource_provider.rs
View File

@@ -98,15 +98,42 @@ impl ResourceProviderService {
/// Get all nodes for a resource_provider
pub fn get_resource_provider_nodes(&self, user_email: &str) -> Vec<FarmNode> {
log::info!(
target: "debug.slice_trace",
"get_resource_provider_nodes:start user={}",
user_email
);
if let Some(data) = UserPersistence::load_user_data(user_email) {
// Debug: Log marketplace SLA data for all nodes
log::info!(
target: "debug.slice_trace",
"get_resource_provider_nodes:loaded_data user={} nodes_count={}",
user_email,
data.nodes.len()
);
// DEBUG: Log slice data for each node to verify what's stored
for node in &data.nodes {
if let Some(ref sla) = node.marketplace_sla {
} else {
}
log::info!(
target: "debug.slice_trace",
"get_resource_provider_nodes:node_data user={} node_id={} grid_node_id={:?} total_base_slices={} allocated_base_slices={} available_combinations_count={} slice_last_calculated={:?}",
user_email,
node.id,
node.grid_node_id,
node.total_base_slices,
node.allocated_base_slices,
node.available_combinations.len(),
node.slice_last_calculated
);
}
data.nodes
} else {
log::info!(
target: "debug.slice_trace",
"get_resource_provider_nodes:no_data user={} returning_empty",
user_email
);
Vec::new()
}
}
@@ -1390,10 +1417,25 @@ impl ResourceProviderService {
/// Add multiple grid nodes at once
pub async fn add_multiple_grid_nodes(&self, user_email: &str, grid_node_ids: Vec<u32>) -> Result<Vec<FarmNode>, String> {
// DEBUG: Log entry point
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:start user={} node_ids={:?}",
user_email,
grid_node_ids
);
// Batch approach: load once, add all nodes, save once
let mut added_nodes: Vec<FarmNode> = Vec::new();
let mut persistent_data = crate::models::builders::SessionDataBuilder::load_or_create(user_email);
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:loaded_existing user={} existing_node_count={}",
user_email,
persistent_data.nodes.len()
);
for grid_node_id in grid_node_ids {
let node_id = format!("grid_node_{}", grid_node_id);
@@ -1415,8 +1457,24 @@ impl ResourceProviderService {
let grid_data = self.grid_service.fetch_node_data(grid_node_id).await.map_err(|e| e.to_string())?;
// FIX: Calculate slice data using the slice calculator (same as add_node_from_grid)
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:calculating_slices user={} grid_node_id={} resources={:?}",
user_email,
grid_node_id,
grid_data.total_resources
);
let total_base_slices = self.slice_calculator.calculate_max_base_slices(&grid_data.total_resources);
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:calculated_slices user={} grid_node_id={} total_base_slices={}",
user_email,
grid_node_id,
total_base_slices
);
// Generate unique node ID for SLA
let node_id_for_sla = node_id.clone();
@@ -1481,23 +1539,93 @@ impl ResourceProviderService {
};
// FIX: Generate initial slice combinations
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:generating_combinations user={} grid_node_id={} total_base_slices={} allocated_base_slices={}",
user_email,
grid_node_id,
node.total_base_slices,
node.allocated_base_slices
);
let combinations = self.slice_calculator.generate_slice_combinations(
node.total_base_slices as u32,
node.allocated_base_slices as u32,
&node,
user_email
);
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:generated_combinations user={} grid_node_id={} combinations_count={}",
user_email,
grid_node_id,
combinations.len()
);
node.available_combinations = combinations.iter()
.map(|c| serde_json::to_value(c).unwrap_or_default())
.collect();
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:node_created user={} node_id={} grid_node_id={} total_slices={} available_combinations={}",
user_email,
node.id,
grid_node_id,
node.total_base_slices,
node.available_combinations.len()
);
persistent_data.nodes.push(node.clone());
added_nodes.push(node);
}
if !added_nodes.is_empty() {
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:saving_data user={} total_nodes_to_save={} added_nodes_count={}",
user_email,
persistent_data.nodes.len(),
added_nodes.len()
);
UserPersistence::save_user_data(&persistent_data).map_err(|e| e.to_string())?;
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:data_saved user={} added_nodes_count={}",
user_email,
added_nodes.len()
);
// DEBUG: Log final node data to verify what was actually saved
for node in &added_nodes {
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:final_node_data user={} node_id={} grid_node_id={:?} total_base_slices={} slice_last_calculated={:?}",
user_email,
node.id,
node.grid_node_id,
node.total_base_slices,
node.slice_last_calculated
);
}
} else {
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:no_nodes_added user={} (all were duplicates or failed)",
user_email
);
}
log::info!(
target: "debug.slice_trace",
"add_multiple_grid_nodes:complete user={} result_count={}",
user_email,
added_nodes.len()
);
Ok(added_nodes)
}

65
src/services/slice_calculator.rs
View File

@@ -143,12 +143,30 @@ impl SliceCalculatorService {
/// Calculate maximum base slices from node capacity
pub fn calculate_max_base_slices(&self, capacity: &NodeCapacity) -> u32 {
log::info!(
target: "debug.slice_trace",
"calculate_max_base_slices:start capacity={:?} base_slice={:?}",
capacity,
self.base_slice
);
let cpu_slices = capacity.cpu_cores as u32 / self.base_slice.cpu_cores;
let memory_slices = capacity.memory_gb as u32 / self.base_slice.memory_gb;
let storage_slices = capacity.storage_gb as u32 / self.base_slice.storage_gb;
let result = std::cmp::min(std::cmp::min(cpu_slices, memory_slices), storage_slices);
log::info!(
target: "debug.slice_trace",
"calculate_max_base_slices:result cpu_slices={} memory_slices={} storage_slices={} limiting_factor={}",
cpu_slices,
memory_slices,
storage_slices,
result
);
// Return the limiting factor
std::cmp::min(std::cmp::min(cpu_slices, memory_slices), storage_slices)
result
}
/// Generate all possible slice combinations from available base slices
@@ -159,10 +177,31 @@ impl SliceCalculatorService {
node: &FarmNode,
resource_provider_email: &str
) -> Vec<SliceCombination> {
log::info!(
target: "debug.slice_trace",
"generate_slice_combinations:start max_base_slices={} allocated_slices={} node_id={} user={}",
max_base_slices,
allocated_slices,
node.id,
resource_provider_email
);
let available_base_slices = max_base_slices.saturating_sub(allocated_slices);
let mut combinations = Vec::new();
log::info!(
target: "debug.slice_trace",
"generate_slice_combinations:available_base_slices={} node_id={}",
available_base_slices,
node.id
);
if available_base_slices == 0 {
log::info!(
target: "debug.slice_trace",
"generate_slice_combinations:no_available_slices node_id={} returning_empty",
node.id
);
return combinations;
}
@@ -216,6 +255,30 @@ impl SliceCalculatorService {
// Sort by multiplier (smallest slices first)
combinations.sort_by_key(|c| c.multiplier);
log::info!(
target: "debug.slice_trace",
"generate_slice_combinations:result node_id={} combinations_count={} available_base_slices={}",
node.id,
combinations.len(),
available_base_slices
);
// DEBUG: Log each combination for detailed analysis
for combination in &combinations {
log::info!(
target: "debug.slice_trace",
"generate_slice_combinations:combination node_id={} id={} multiplier={} quantity={} cpu={} memory={} storage={}",
node.id,
combination.id,
combination.multiplier,
combination.quantity_available,
combination.cpu_cores,
combination.memory_gb,
combination.storage_gb
);
}
combinations
}