Mirror/seaweedfs - seaweedfs - Gitea: Git with a cup of tea

Author	SHA1	Message	Date
Chris Lu	71cc233fac	add missing action	1 day ago
Chris Lu	88ed187c27	fix(worker): add metrics HTTP server and health checks for Kubernetes (#7860 ) * feat(worker): add metrics HTTP server and debug profiling support - Add -metricsPort flag to enable Prometheus metrics endpoint - Add -metricsIp flag to configure metrics server bind address - Implement /metrics endpoint for Prometheus-compatible metrics - Implement /health endpoint for Kubernetes readiness/liveness probes - Add -debug flag to enable pprof debugging server - Add -debug.port flag to configure debug server port - Fix stats package import naming conflict by using alias - Update usage examples to show new flags Fixes #7843 * feat(helm): add worker metrics and health check support - Update worker readiness probe to use httpGet on /health endpoint - Update worker liveness probe to use httpGet on /health endpoint - Add metricsPort flag to worker command in deployment template - Support both httpGet and tcpSocket probe types for backward compatibility - Update values.yaml with health check configuration This enables Kubernetes pod lifecycle management for worker components through proper health checks on the new metrics HTTP endpoint. * feat(mini): align all services to share single debug and metrics servers - Disable S3's separate debug server in mini mode (port 6060 now shared by all) - Add metrics server startup to embedded worker for health monitoring - All services now share the single metrics port (9327) and single debug port (6060) - Consistent pattern with master, filer, volume, webdav services * fix(worker): fix variable shadowing in health check handler - Rename http.ResponseWriter parameter from 'w' to 'rw' to avoid shadowing the outer 'w worker.Worker' parameter - Prevents potential bugs if future code tries to use worker state in handler - Improves code clarity and follows Go best practices fix(worker): remove unused worker parameter in metrics server - Change 'w worker.Worker' parameter to '_' as it's not used - Clarifies intent that parameter is intentionally unused - Follows Go best practices and improves code clarity fix(helm): fix trailing backslash syntax errors in worker command - Fix conditional backslash placement to prevent shell syntax errors - Only add backslash when metricsPort OR extraArgs are present - Prevents worker pod startup failures due to malformed command arguments - Ensures proper shell command parsing regardless of configuration state * refactor(worker): use standard stats.StartMetricsServer for consistency - Replace custom metrics server implementation with stats.StartMetricsServer to match pattern used in master, volume, s3, filer_sync components - Simplifies code and improves maintainability - Uses glog.Fatal for errors (consistent with other SeaweedFS components) - Remove unused net/http and prometheus/promhttp imports - Automatically provides /metrics and /health endpoints via standard implementation	2 days ago
Chris Lu	14df5d1bb5	fix: improve worker reconnection robustness and prevent handleOutgoing hang (#7838 ) * feat: add automatic port detection and fallback for mini command - Added port availability detection using TCP binding tests - Implemented port fallback mechanism searching for available ports - Support for both HTTP and gRPC port handling - IP-aware port checking using actual service bind address - Dual-interface verification (specific IP and wildcard 0.0.0.0) - All services (Master, Volume, Filer, S3, WebDAV, Admin) auto-reallocate to available ports - Enables multiple mini instances to run simultaneously without conflicts * fix: use actual bind IP for service health checks - Previously health checks were hardcoded to localhost (127.0.0.1) - This caused failures when services bind to actual IP (e.g., 10.21.153.8) - Now health checks use the same IP that services are binding to - Fixes Volume and other service health check failures on non-localhost IPs * refactor: improve port detection logic and remove gRPC handling duplication - findAvailablePortOnIP now returns 0 on failure instead of unavailable port Allows callers to detect when port finding fails and handle appropriately - Remove duplicate gRPC port handling from ensureAllPortsAvailableOnIP All gRPC port logic is now centralized in initializeGrpcPortsOnIP - Log final port configuration only after all ports are finalized Both HTTP and gRPC ports are now correctly initialized before logging - Add error logging when port allocation fails Makes debugging easier when ports can't be found * refactor: fix race condition and clean up port detection code - Convert parallel HTTP port checks to sequential to prevent race conditions where multiple goroutines could allocate the same available port - Remove unused 'sync' import since WaitGroup is no longer used - Add documentation to localhost wrapper functions explaining they are kept for backwards compatibility and future use - All gRPC port logic is now exclusively handled in initializeGrpcPortsOnIP eliminating any duplication in ensureAllPortsAvailableOnIP * refactor: address code review comments - constants, helper function, and cleanup - Define GrpcPortOffset constant (10000) to replace magic numbers throughout the code for better maintainability and consistency - Extract bindIp determination logic into getBindIp() helper function to eliminate code duplication between runMini and startMiniServices - Remove redundant 'calculatedPort = calculatedPort' assignment that had no effect - Update all gRPC port calculations to use GrpcPortOffset constant (lines 489, 886 and the error logging at line 501) * refactor: remove unused wrapper functions and update documentation - Remove unused localhost wrapper functions that were never called: - isPortOpen() - wrapper around isPortOpenOnIP with hardcoded 127.0.0.1 - findAvailablePort() - wrapper around findAvailablePortOnIP with hardcoded 127.0.0.1 - ensurePortAvailable() - wrapper around ensurePortAvailableOnIP with hardcoded 127.0.0.1 - ensureAllPortsAvailable() - wrapper around ensureAllPortsAvailableOnIP with hardcoded 127.0.0.1 Since this is new functionality with no backwards compatibility concerns, these wrapper functions were not needed. The comments claiming they were 'kept for future use or backwards compatibility' are no longer valid. - Update documentation to reference GrpcPortOffset constant instead of hardcoded 10000: - Update comment in ensureAllPortsAvailableOnIP to use GrpcPortOffset - Update admin.port.grpc flag help text to reference GrpcPortOffset Note: getBindIp() is actually being used and should be retained (contrary to the review comment suggesting it was unused - it's called in both runMini and startMiniServices functions) * refactor: prevent HTTP/gRPC port collisions and improve error handling - Add upfront reservation of all calculated gRPC ports before allocating HTTP ports to prevent collisions where an HTTP port allocation could use a port that will later be needed for a gRPC port calculation. Example scenario that is now prevented: - Master HTTP reallocated from 9333 to 9334 (original in use) - Filer HTTP search finds 19334 available and assigns it - Master gRPC calculated as 9334 + GrpcPortOffset = 19334 → collision! Now: reserved gRPC ports are tracked upfront and HTTP port search skips them. - Improve admin server gRPC port fallback error handling: - Change from silent V(1) verbose log to Warningf to make the error visible - Update comment to clarify this indicates a problem in the port initialization sequence - Add explanation that the fallback calculation may cause bind failure - Update ensureAllPortsAvailableOnIP comment to clarify it avoids reserved ports * fix: enforce reserved ports in HTTP allocation and improve admin gRPC fallback Critical fixes for port allocation safety: 1. Make findAvailablePortOnIP and ensurePortAvailableOnIP aware of reservedPorts: - Add reservedPorts map parameter to both functions - findAvailablePortOnIP now skips reserved ports when searching for alternatives - ensurePortAvailableOnIP passes reservedPorts through to findAvailablePortOnIP - This prevents HTTP ports from being allocated to ports reserved for gRPC 2. Update ensureAllPortsAvailableOnIP to pass reservedPorts: - Pass the reservedPorts map to ensurePortAvailableOnIP calls - Maintains the map updates (delete/add) for accuracy as ports change 3. Replace blind admin gRPC port fallback with proper availability checks: - Previous code just calculated miniAdminOptions.port + GrpcPortOffset - New code checks both the calculated port and finds alternatives if needed - Uses the same availability checking logic as initializeGrpcPortsOnIP - Properly logs the fallback process and any port changes - Will fail gracefully if no available ports found (consistent with other services) These changes eliminate two critical vulnerabilities: - HTTP port allocation can no longer accidentally claim gRPC ports - Admin gRPC port fallback no longer blindly uses an unchecked port fix: prevent gRPC port collisions during multi-service fallback allocation Critical fix for gRPC port allocation safety across multiple services: Problem: When multiple services need gRPC port fallback allocation in sequence (e.g., Master gRPC unavailable → finds alternative, then Filer gRPC unavailable → searches from calculated port), there was no tracking of previously allocated gRPC ports. This could allow two services to claim the same port. Scenario that is now prevented: - Master gRPC: calculated 19333 unavailable → finds 19334 → assigns 19334 - Filer gRPC: calculated 18888 unavailable → searches from 18889, might land on 19334 if consecutive ports in range are unavailable (especially with custom port configurations or in high-port-contention environments) Solution: - Add allocatedGrpcPorts map to track gRPC ports allocated within the function - Check allocatedGrpcPorts before using calculated port for each service - Pass allocatedGrpcPorts to findAvailablePortOnIP when finding fallback ports - Add allocatedGrpcPorts[port] = true after each successful allocation - This ensures no two services can allocate the same gRPC port The fix handles both: 1. Calculated gRPC ports (when grpcPort == 0) 2. Explicitly set gRPC ports (when user provides -service.port.grpc value) While default port spacing makes collision unlikely, this fix is essential for: - Custom port configurations - High-contention environments - Edge cases with many unavailable consecutive ports - Correctness and safety guarantees * feat: enforce hard-fail behavior for explicitly specified ports When users explicitly specify a port via command-line flags (e.g., -s3.port=8333), the server should fail immediately if the port is unavailable, rather than silently falling back to an alternative port. This prevents user confusion and makes misconfiguration failures obvious. Changes: - Modified ensurePortAvailableOnIP() to check if a port was explicitly passed via isFlagPassed() - If an explicit port is unavailable, return error instead of silently allocating alternative - Updated ensureAllPortsAvailableOnIP() to handle the returned error and fail startup - Modified runMini() to check error from ensureAllPortsAvailableOnIP() and return false on failure - Default ports (not explicitly specified) continue to fallback to available alternatives This ensures: - Explicit ports: fail if unavailable (e.g., -s3.port=8333 fails if 8333 is taken) - Default ports: fallback to alternatives (e.g., s3.port without flag falls back to 8334 if 8333 taken) * fix: accurate error messages for explicitly specified unavailable ports When a port is explicitly specified via CLI flags but is unavailable, the error message now correctly reports the originally requested port instead of reporting a fallback port that was calculated internally. The issue was that the config file applied after CLI flag parsing caused isFlagPassed() to return true for ports loaded from the config file (since flag.Visit() was called during config file application), incorrectly marking them as explicitly specified. Solution: Capture which port flags were explicitly passed on the CLI BEFORE the config file is applied, storing them in the explicitPortFlags map. This preserves the accurate distinction between user-specified ports and defaults/config-file ports. Example: - User runs: weed mini -dir=. -s3.port=22 - Now correctly shows: 'port 22 for S3 (specified by flag s3.port) is not available' - Previously incorrectly showed: 'port 8334 for S3...' (some calculated fallback) * fix: respect explicitly specified ports and prevent config file override When a port is explicitly specified via CLI flags (e.g., -s3.port=8333), the config file options should NOT override it. Previously, config file options would be applied if the flag value differed from default, but this check wasn't sufficient to prevent override in all cases. Solution: Check the explicitPortFlags map before applying any config file port options. If a port was explicitly passed on the CLI, skip applying the config file option for that port. This ensures: - Explicit ports take absolute precedence over config file ports - Config file ports are only used if port wasn't specified on CLI - Example: 'weed mini -s3.port=8333' will use 8333, never the config file value * fix: don't print usage on port allocation error When a port allocation fails (e.g., explicit port is unavailable), exit immediately without showing the usage example. This provides cleaner error output when the error is expected (port conflict). * refactor: clean up code quality issues Remove no-op assignment (calculatedPort = calculatedPort) that had no effect. The variable already holds the correct value when no alternative port is found. Improve documentation for the defensive gRPC port initialization fallback in startAdminServer. While this code shouldn't execute in normal flow because ensureAllPortsAvailableOnIP is called earlier in runMini, the fallback handles edge cases where port initialization may have been skipped or failed silently due to configuration changes or error handling paths. * fix: improve worker reconnection robustness and prevent handleOutgoing hang - Add dedicated streamFailed signaling channel to abort registration waits early when stream dies - Add per-connection regWait channel to route RegistrationResponse separately from shared incoming channel, avoiding race where other consumers steal the response - Refactor handleOutgoing() loop to use select on streamExit/errCh, ensuring old handlers exit cleanly on reconnect (prevents stale senders competing with new stream) - Buffer msgCh to reduce shutdown edge cases - Add cleanup of streamFailed and regWait channels on reconnect/disconnect - Fixes registration timeout and potential stream lifecycle hangs on aggressive server max_age recycling * fix: prevent deadlock when stream error occurs - make cmds send non-blocking If managerLoop is blocked (e.g., waiting on regWait), a blocking send to cmds will deadlock handleIncoming. Make the send non-blocking to prevent this. * fix: address code review comments on mini.go port allocation - Remove flawed fallback gRPC port initialization and convert to fatal error (ensures port initialization issues are caught immediately instead of silently failing with an empty reserved ports map) - Extract common port validation logic to eliminate duplication between calculated and explicitly set gRPC port handling * Fix critical race condition and improve error handling in worker client - Capture channel pointers before checking for nil (prevents TOCTOU race with reconnect) - Use async fallback goroutine for cmds send to prevent error loss when manager is busy - Consistently close regWait channel on disconnect (matches streamFailed behavior) - Complete cleanup of channels on failed registration - Improve error messages for clarity (replace 'timeout' with 'failed' where appropriate) * Add debug logging for registration response routing Add glog.V(3) and glog.V(2) logs to track successful and dropped registration responses in handleIncoming, helping diagnose registration issues in production. * Update weed/worker/client.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Ensure stream errors are never lost by using async fallback When handleIncoming detects a stream error, queue ActionStreamError to managerLoop with non-blocking send. If managerLoop is busy and cmds channel is full, spawn an async goroutine to queue the error asynchronously. This ensures the manager is always notified of stream failures, preventing the connection from remaining in an inconsistent state (connected=true while stream is dead). * Refactor handleOutgoing to eliminate duplicate error handling code Extract error handling and cleanup logic into helper functions to avoid duplication in nested select statements. This improves maintainability and reduces the risk of inconsistencies when updating error handling logic. * Prevent goroutine leaks by adding timeouts to blocking cmds sends Add 2-second timeouts to both handleStreamError and the async fallback goroutine when sending ActionStreamError to cmds channel. This prevents the handleOutgoing and handleIncoming goroutines from blocking indefinitely if the managerLoop is no longer receiving (e.g., during shutdown), preventing resource leaks. * Properly close regWait channel in reconnect to prevent resource leaks Close the regWait channel before setting it to nil in reconnect(), matching the pattern used in handleDisconnect(). This ensures any goroutines waiting on this channel during reconnection are properly signaled, preventing them from hanging. * Use non-blocking async pattern in handleOutgoing error reporting Refactor handleStreamError to use non-blocking send with async fallback goroutine, matching the pattern used in handleIncoming. This allows handleOutgoing to exit immediately when errors occur rather than blocking for up to 2 seconds, improving responsiveness and consistency across handlers. * fix: drain regWait channel before closing to prevent message loss - Add drain loop before closing regWait in reconnect() cleanup - Add drain loop before closing regWait in handleDisconnect() cleanup - Ensures no pending RegistrationResponse messages are lost during channel closure * docs: add comments explaining regWait buffered channel design - Document that regWait buffer size 1 prevents race conditions - Explain non-blocking send pattern between sendRegistration and handleIncoming - Clarify timing of registration response handling in handleIncoming * fix: improve error messages and channel handling in sendRegistration - Clarify error message when stream fails before registration sent - Use two-value receive form to properly detect closed channels - Better distinguish between closed channel and nil value scenarios * refactor: extract drain and close channel logic into helper function - Create drainAndCloseRegWaitChannel() helper to eliminate code duplication - Replace 3 copies of drain-and-close logic with single function call - Improves maintainability and consistency across cleanup paths --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	3 days ago
Chris Lu	9a4f32fc49	feat: add automatic port detection and fallback for mini command (#7836 ) * feat: add automatic port detection and fallback for mini command - Added port availability detection using TCP binding tests - Implemented port fallback mechanism searching for available ports - Support for both HTTP and gRPC port handling - IP-aware port checking using actual service bind address - Dual-interface verification (specific IP and wildcard 0.0.0.0) - All services (Master, Volume, Filer, S3, WebDAV, Admin) auto-reallocate to available ports - Enables multiple mini instances to run simultaneously without conflicts * fix: use actual bind IP for service health checks - Previously health checks were hardcoded to localhost (127.0.0.1) - This caused failures when services bind to actual IP (e.g., 10.21.153.8) - Now health checks use the same IP that services are binding to - Fixes Volume and other service health check failures on non-localhost IPs * refactor: improve port detection logic and remove gRPC handling duplication - findAvailablePortOnIP now returns 0 on failure instead of unavailable port Allows callers to detect when port finding fails and handle appropriately - Remove duplicate gRPC port handling from ensureAllPortsAvailableOnIP All gRPC port logic is now centralized in initializeGrpcPortsOnIP - Log final port configuration only after all ports are finalized Both HTTP and gRPC ports are now correctly initialized before logging - Add error logging when port allocation fails Makes debugging easier when ports can't be found * refactor: fix race condition and clean up port detection code - Convert parallel HTTP port checks to sequential to prevent race conditions where multiple goroutines could allocate the same available port - Remove unused 'sync' import since WaitGroup is no longer used - Add documentation to localhost wrapper functions explaining they are kept for backwards compatibility and future use - All gRPC port logic is now exclusively handled in initializeGrpcPortsOnIP eliminating any duplication in ensureAllPortsAvailableOnIP * refactor: address code review comments - constants, helper function, and cleanup - Define GrpcPortOffset constant (10000) to replace magic numbers throughout the code for better maintainability and consistency - Extract bindIp determination logic into getBindIp() helper function to eliminate code duplication between runMini and startMiniServices - Remove redundant 'calculatedPort = calculatedPort' assignment that had no effect - Update all gRPC port calculations to use GrpcPortOffset constant (lines 489, 886 and the error logging at line 501) * refactor: remove unused wrapper functions and update documentation - Remove unused localhost wrapper functions that were never called: - isPortOpen() - wrapper around isPortOpenOnIP with hardcoded 127.0.0.1 - findAvailablePort() - wrapper around findAvailablePortOnIP with hardcoded 127.0.0.1 - ensurePortAvailable() - wrapper around ensurePortAvailableOnIP with hardcoded 127.0.0.1 - ensureAllPortsAvailable() - wrapper around ensureAllPortsAvailableOnIP with hardcoded 127.0.0.1 Since this is new functionality with no backwards compatibility concerns, these wrapper functions were not needed. The comments claiming they were 'kept for future use or backwards compatibility' are no longer valid. - Update documentation to reference GrpcPortOffset constant instead of hardcoded 10000: - Update comment in ensureAllPortsAvailableOnIP to use GrpcPortOffset - Update admin.port.grpc flag help text to reference GrpcPortOffset Note: getBindIp() is actually being used and should be retained (contrary to the review comment suggesting it was unused - it's called in both runMini and startMiniServices functions) * refactor: prevent HTTP/gRPC port collisions and improve error handling - Add upfront reservation of all calculated gRPC ports before allocating HTTP ports to prevent collisions where an HTTP port allocation could use a port that will later be needed for a gRPC port calculation. Example scenario that is now prevented: - Master HTTP reallocated from 9333 to 9334 (original in use) - Filer HTTP search finds 19334 available and assigns it - Master gRPC calculated as 9334 + GrpcPortOffset = 19334 → collision! Now: reserved gRPC ports are tracked upfront and HTTP port search skips them. - Improve admin server gRPC port fallback error handling: - Change from silent V(1) verbose log to Warningf to make the error visible - Update comment to clarify this indicates a problem in the port initialization sequence - Add explanation that the fallback calculation may cause bind failure - Update ensureAllPortsAvailableOnIP comment to clarify it avoids reserved ports * fix: enforce reserved ports in HTTP allocation and improve admin gRPC fallback Critical fixes for port allocation safety: 1. Make findAvailablePortOnIP and ensurePortAvailableOnIP aware of reservedPorts: - Add reservedPorts map parameter to both functions - findAvailablePortOnIP now skips reserved ports when searching for alternatives - ensurePortAvailableOnIP passes reservedPorts through to findAvailablePortOnIP - This prevents HTTP ports from being allocated to ports reserved for gRPC 2. Update ensureAllPortsAvailableOnIP to pass reservedPorts: - Pass the reservedPorts map to ensurePortAvailableOnIP calls - Maintains the map updates (delete/add) for accuracy as ports change 3. Replace blind admin gRPC port fallback with proper availability checks: - Previous code just calculated miniAdminOptions.port + GrpcPortOffset - New code checks both the calculated port and finds alternatives if needed - Uses the same availability checking logic as initializeGrpcPortsOnIP - Properly logs the fallback process and any port changes - Will fail gracefully if no available ports found (consistent with other services) These changes eliminate two critical vulnerabilities: - HTTP port allocation can no longer accidentally claim gRPC ports - Admin gRPC port fallback no longer blindly uses an unchecked port fix: prevent gRPC port collisions during multi-service fallback allocation Critical fix for gRPC port allocation safety across multiple services: Problem: When multiple services need gRPC port fallback allocation in sequence (e.g., Master gRPC unavailable → finds alternative, then Filer gRPC unavailable → searches from calculated port), there was no tracking of previously allocated gRPC ports. This could allow two services to claim the same port. Scenario that is now prevented: - Master gRPC: calculated 19333 unavailable → finds 19334 → assigns 19334 - Filer gRPC: calculated 18888 unavailable → searches from 18889, might land on 19334 if consecutive ports in range are unavailable (especially with custom port configurations or in high-port-contention environments) Solution: - Add allocatedGrpcPorts map to track gRPC ports allocated within the function - Check allocatedGrpcPorts before using calculated port for each service - Pass allocatedGrpcPorts to findAvailablePortOnIP when finding fallback ports - Add allocatedGrpcPorts[port] = true after each successful allocation - This ensures no two services can allocate the same gRPC port The fix handles both: 1. Calculated gRPC ports (when grpcPort == 0) 2. Explicitly set gRPC ports (when user provides -service.port.grpc value) While default port spacing makes collision unlikely, this fix is essential for: - Custom port configurations - High-contention environments - Edge cases with many unavailable consecutive ports - Correctness and safety guarantees * feat: enforce hard-fail behavior for explicitly specified ports When users explicitly specify a port via command-line flags (e.g., -s3.port=8333), the server should fail immediately if the port is unavailable, rather than silently falling back to an alternative port. This prevents user confusion and makes misconfiguration failures obvious. Changes: - Modified ensurePortAvailableOnIP() to check if a port was explicitly passed via isFlagPassed() - If an explicit port is unavailable, return error instead of silently allocating alternative - Updated ensureAllPortsAvailableOnIP() to handle the returned error and fail startup - Modified runMini() to check error from ensureAllPortsAvailableOnIP() and return false on failure - Default ports (not explicitly specified) continue to fallback to available alternatives This ensures: - Explicit ports: fail if unavailable (e.g., -s3.port=8333 fails if 8333 is taken) - Default ports: fallback to alternatives (e.g., s3.port without flag falls back to 8334 if 8333 taken) * fix: accurate error messages for explicitly specified unavailable ports When a port is explicitly specified via CLI flags but is unavailable, the error message now correctly reports the originally requested port instead of reporting a fallback port that was calculated internally. The issue was that the config file applied after CLI flag parsing caused isFlagPassed() to return true for ports loaded from the config file (since flag.Visit() was called during config file application), incorrectly marking them as explicitly specified. Solution: Capture which port flags were explicitly passed on the CLI BEFORE the config file is applied, storing them in the explicitPortFlags map. This preserves the accurate distinction between user-specified ports and defaults/config-file ports. Example: - User runs: weed mini -dir=. -s3.port=22 - Now correctly shows: 'port 22 for S3 (specified by flag s3.port) is not available' - Previously incorrectly showed: 'port 8334 for S3...' (some calculated fallback) * fix: respect explicitly specified ports and prevent config file override When a port is explicitly specified via CLI flags (e.g., -s3.port=8333), the config file options should NOT override it. Previously, config file options would be applied if the flag value differed from default, but this check wasn't sufficient to prevent override in all cases. Solution: Check the explicitPortFlags map before applying any config file port options. If a port was explicitly passed on the CLI, skip applying the config file option for that port. This ensures: - Explicit ports take absolute precedence over config file ports - Config file ports are only used if port wasn't specified on CLI - Example: 'weed mini -s3.port=8333' will use 8333, never the config file value * fix: don't print usage on port allocation error When a port allocation fails (e.g., explicit port is unavailable), exit immediately without showing the usage example. This provides cleaner error output when the error is expected (port conflict). * fix: increase worker registration timeout for reconnections Increase the worker registration timeout from 10 seconds to 30 seconds. The 10-second timeout was too aggressive for reconnections when the admin server might be busy processing other operations. Reconnecting workers need more time to: 1. Re-establish the gRPC connection 2. Send the registration message 3. Wait for the admin server to process and respond This prevents spurious "registration timeout" errors during long-running mini instances when brief network hiccups or admin server load cause delays. * refactor: clean up code quality issues Remove no-op assignment (calculatedPort = calculatedPort) that had no effect. The variable already holds the correct value when no alternative port is found. Improve documentation for the defensive gRPC port initialization fallback in startAdminServer. While this code shouldn't execute in normal flow because ensureAllPortsAvailableOnIP is called earlier in runMini, the fallback handles edge cases where port initialization may have been skipped or failed silently due to configuration changes or error handling paths.	3 days ago
Chris Lu	1dfda78e59	update doc	4 days ago
Chris Lu	31cb28d9d3	feat: auto-configure optimal volume size limit based on available disk space (#7833 ) * feat: auto-configure optimal volume size limit based on available disk space - Add calculateOptimalVolumeSizeMB() function with OS-independent disk detection - Reuses existing stats.NewDiskStatus() which works across Linux, macOS, Windows, BSD, Solaris - Algorithm: available disk / 100, rounded up to nearest power of 2 (64MB, 128MB, 256MB, 512MB, 1024MB) - Volume size capped to maximum of 1GB (1024MB) for better stability - Minimum volume size is 64MB - Uses efficient bits.Len() for power-of-2 rounding instead of floating-point operations - Only auto-calculates volume size if user didn't specify a custom value via -master.volumeSizeLimitMB - Respects user-specified values without override - Master logs whether value was auto-calculated or user-specified - Welcome message displays the configured volume size with correct format string ordering - Removed unused autoVolumeSizeMB variable (logging handles source tracking) Fixes: #0 * Refactor: Consolidate volume size constants and use robust flag detection for mini mode This commit addresses all code review feedback on the auto-optimal volume size feature: 1. Consolidate hardcoded defaults into package-level constants - Moved minVolumeSizeMB=64 and maxVolumeSizeMB=1024 from local function-scope constants to package-level constants for consistency and maintainability - All three volume size constants (min, default, max) now defined in one place 2. Implement robust flag detection using flag.Visit() - Added isFlagPassed() helper function using flag.Visit() to check if a CLI flag was explicitly passed on the command line - Replaces the previous implementation that checked if current value equals default (which could incorrectly assume user intent if default was specified) - Now correctly detects user override regardless of the actual value 3. Restructure power-of-2 rounding logic for clarity - Changed from 'only round if above min threshold' to 'always round to power-of-2 first, then apply min/max constraints' - More robust: works correctly even if min/max constants are adjusted in future - Clearer intent: all non-zero values go through consistent rounding logic 4. Fix import ordering - Added 'flag' import (aliased to fla9 package) to support isFlagPassed() - Added 'math/bits' import to support power-of-2 rounding Benefits: - Better code organization with all volume size limits in package constants - Correct user override detection that doesn't rely on value equality checks - More maintainable rounding logic that's easier to understand and modify - Consistent with SeaweedFS conventions (uses fla9 package like other commands) * fix: Address code review feedback for volume size calculation This commit resolves three code review comments for better code quality and robustness: 1. Handle comma-separated directories in -dir flag - The -dir flag accepts comma-separated list of directories, but the volume size calculation was passing the entire string to util.ResolvePath() - Now splits on comma and uses the first directory for disk space calculation - Added explanatory comment about the multi-directory support - Ensures the optimal size calculation works correctly in all scenarios 2. Change disk detection failure from verbose log to warning - When disk status cannot be determined, the warning is now logged via glog.Warningf() instead of glog.V(1).Infof() - Makes the event visible in default logs without requiring verbose mode - Better alerting for operators about fallback to default values 3. Avoid recalculating availableMB/100 and define bytesPerMB constant - Added bytesPerMB = 10241024 constant for clarity and reusability - Replaced hardcoded (1024 1024) with bytesPerMB constant - Store availableMB/100 in initialOptimalMB variable to avoid recalculation - Log message now references initialOptimalMB instead of recalculating - Improves maintainability and reduces redundant computation All three changes maintain the same logic while improving code quality and robustness as requested by the reviewer. * fix: Address rounding logic, logging clarity, and disk capacity measurement issues This commit resolves three additional code review comments to improve robustness and clarity of the volume size calculation: 1. Fix power-of-2 rounding logic for edge cases - The previous condition 'if optimalMB > 0' created a bug: when optimalMB=1, bits.Len(0)=0, resulting in 1<<0=1, which is below minimum (64MB) - Changed to explicitly handle zero case first: 'if optimalMB == 0' - Separate zero-handling from power-of-2 rounding ensures correct behavior: * optimalMB=0 → set to minVolumeSizeMB (64) * optimalMB>=1 → apply power-of-2 rounding - Then apply min/max constraints unconditionally - More explicit and easier to reason about correctness 2. Use total disk capacity instead of free space for stable configuration - Changed from diskStatus.Free (available space) to diskStatus.All (total capacity) - Free space varies based on current disk usage at startup time - This caused inconsistent volume sizes: same disk could get different sizes depending on how full it is when the service starts - Using total capacity ensures predictable, stable configuration across restarts - Better aligns with the intended behavior of sizing based on disk capacity - Added explanatory comments about why total capacity is more appropriate 3. Improve log message clarity and accuracy - Updated message to clearly show: * 'total disk capacity' instead of vague 'available disk' * 'capacity/100 before rounding' to match actual calculation * 'clamped to [min,max]' instead of 'capped to max' to show both bounds * Includes min and max values in log for context - More accurate and helpful for operators troubleshooting volume sizing These changes ensure the volume size calculation is both correct and predictable. * feat: Save mini configuration to file for persistence and documentation This commit adds persistent configuration storage for the 'weed mini' command, saving all non-default parameters to a JSON configuration file for: 1. Configuration Documentation - All parameters actually passed on the command line are saved - Provides a clear record of the running configuration - Useful for auditing and understanding how the system is configured 2. Persistence of Auto-Calculated Values - The auto-calculated optimal volume size (master.volumeSizeLimitMB) is saved with a note indicating it was auto-calculated - On restart, if the auto-calculated value exists, it won't be recalculated - Users can delete the auto-calculated entry to force recalculation on next startup - Provides stable, predictable configuration across restarts 3. Configuration File Location - Saved to: <data-folder>/.seaweedfs/mini.config.json - Uses the first directory from comma-separated -dir list - Directory is created automatically if it doesn't exist - JSON format for easy parsing and manual editing 4. Implementation Details - Uses flag.Visit() to collect only explicitly passed flags - Distinguishes between user-specified and auto-calculated values - Includes helpful notes in the JSON file - Graceful handling of save errors (logs warnings, doesn't fail startup) The configuration file includes all parameters such as: - IP and port settings (master, filer, volume, admin) - Data directories and metadata folders - Replication and collection settings - S3 and IAM configurations - Performance tuning parameters (concurrency limits, timeouts, etc.) - Auto-calculated volume size (if applicable) Example mini.config.json output: { "debug": "true", "dir": "/data/seaweedfs", "master.port": "9333", "filer.port": "8888", "volume.port": "9340", "master.volumeSizeLimitMB.auto": "256", "_note_auto_calculated": "This value was auto-calculated. Remove it to recalculate on next startup." } This allows operators to: - Review what configuration was active - Replicate the configuration on other systems - Understand the startup behavior - Control when auto-calculation occurs * refactor: Change configuration file format to match command-line options format Update the saved configuration format from JSON to shell-compatible options format that matches how options are expected to be passed on the command line. Configuration file: .seaweedfs/mini.options Format: Each line contains a command-line option in the format -name=value Benefits: - Format is compatible with shell scripts and can be sourced - Can be easily converted to command-line options - Human-readable and editable - Values with spaces are properly quoted - Includes helpful comments explaining auto-calculated values - Directly usable with weed mini command The file can be used in multiple ways: 1. Extract options: cat .seaweedfs/mini.options \| grep -v '^#' \| tr '\n' ' ' 2. Inline in command: weed mini \$(cat .seaweedfs/mini.options \| grep -v '^#') 3. Manual review: cat .seaweedfs/mini.options * refactor: Save mini.options directly to -dir folder * docs: Update PR description with accurate algorithm and examples Update the function documentation comments to accurately reflect the implemented algorithm and provide real-world examples with actual calculated outputs. Changes: - Clarify that algorithm uses total disk capacity (not free space) - Document exact calculation: capacity/100, round to power of 2, clamp to [64,1024] - Add realistic examples showing input disk sizes and resulting volume sizes: * 10GB disk → 64MB (minimum) * 100GB disk → 64MB (minimum) * 1TB disk → 64MB (minimum) * 6.4TB disk → 64MB * 12.8TB disk → 128MB * 100TB disk → 1024MB (maximum) * 1PB disk → 1024MB (maximum) - Include note that values are rounded to next power of 2 and capped at 1GB This helps users understand the volume size calculation and predict what size will be set for their specific disk configurations. * feat: integrate configuration file loading into mini startup - Load mini.options file at startup if it exists - Apply loaded configuration options before normal initialization - CLI flags override file-based configuration - Exclude 'dir' option from being saved (environment-specific) - Configuration file format: option=value without leading dashes - Auto-calculated volume size persists with recalculation marker	4 days ago
Chris Lu	3613279f25	Add 'weed mini' command for S3 beginners and small/dev use cases (#7831 ) * Add 'weed mini' command for S3 beginners and small/dev use cases This new command simplifies starting SeaweedFS by combining all components in one process with optimized settings for development and small deployments. Features: - Starts master, volume, filer, S3, WebDAV, and admin in one command - Volume size limit: 64MB (optimized for small files) - Volume max: 0 (auto-configured based on free disk space) - Pre-stop seconds: 1 (faster shutdown for development) - Master peers: none (single master mode by default) - Includes admin UI with one worker for maintenance tasks - Clean, user-friendly startup message with all endpoint URLs Usage: weed mini # Use default temp directory weed mini -dir=/data # Custom data directory This makes it much easier for: - Developers getting started with SeaweedFS - Testing and development workflows - Learning S3 API with SeaweedFS - Small deployments that don't need complex clustering * Change default volume server port to 9340 to avoid popular port 8080 * Fix nil pointer dereference by initializing all required volume server fields Added missing VolumeServerOptions field initializations: - id, publicUrl, diskType - maintenanceMBPerSecond, ldbTimeout - concurrentUploadLimitMB, concurrentDownloadLimitMB - pprof, idxFolder - inflightUploadDataTimeout, inflightDownloadDataTimeout - hasSlowRead, readBufferSizeMB This resolves the panic that occurred when starting the volume server. * Fix multiple nil pointer dereferences in mini command Added missing field initializations for: - Master options: raftHashicorp, raftBootstrap, telemetryUrl, telemetryEnabled - Filer options: filerGroup, saveToFilerLimit, concurrentUploadLimitMB, concurrentFileUploadLimit, localSocket, showUIDirectoryDelete, downloadMaxMBps, diskType, allowedOrigins, exposeDirectoryData, tusBasePath - Volume options: id, publicUrl, diskType, maintenanceMBPerSecond, ldbTimeout, concurrentUploadLimitMB, concurrentDownloadLimitMB, pprof, idxFolder, inflightUploadDataTimeout, inflightDownloadDataTimeout, hasSlowRead, readBufferSizeMB - WebDAV options: tlsPrivateKey, tlsCertificate, filerRootPath - Admin options: master These initializations are required to avoid runtime panics when starting components. * Fix remaining S3 option nil pointers in mini command * Update mini command: 256MB volume size and add S3 access instructions for beginners * mini: set default master.volumeSizeLimitMB to 128MB and update help/banner text * mini: shorten S3 help text to a concise pointer to docs/Admin UI * mini: remove duplicated component bullet list, use concise sentence * mini: tidy help alignment and update example usage * mini: default -dir to current directory * mini: load initial S3 credentials from env and write IAM config * mini: use AWS env vars for initial S3 creds; instruct to create via Admin UI if absent * Improve startup synchronization with channel-based coordination - Replace fragile time.Sleep delays with robust channel-based synchronization - Implement proper service dependency ordering (Master → Volume → Filer → S3/WebDAV/Admin) - Add sync.WaitGroup for goroutine coordination - Add startup readiness logging for better visibility - Implement 10-second timeout for admin server startup - Remove arbitrary sleep delays for faster, more reliable startup - Services now start deterministically based on dependencies, not timing This makes the startup process more reliable and eliminates race conditions on slow systems or under load. * Refactor service startup logic for better maintainability Extract service startup into dedicated helper functions: - startMiniServices(): Orchestrates all service startup with dependency coordination - startServiceWithCoordination(): Starts services with readiness signaling - startServiceWithoutReady(): Starts services without readiness signaling - startS3Service(): Encapsulates S3 initialization logic Benefits: - Reduced code duplication in runMini() - Clearer separation of concerns - Easier to add new services or modify startup sequence - More testable code structure - Improved readability with explicit service names and logging * Remove unused serviceStartupInfo struct type - Delete the serviceStartupInfo struct that was defined but never used - Improves code clarity by removing dead code - All service startup is now handled directly by helper functions * Preserve existing IAM config file instead of truncating - Use os.Stat to check if IAM config file already exists - Only create and write configuration if file doesn't exist - Log appropriate messages for each case: * File exists: skip writing, preserve existing config * File absent: create with os.OpenFile and write new config * Stat error: log error without overwriting - Set miniIamConfig only when new file is successfully created - Use os.O_CREATE\|os.O_WRONLY flags for safe file creation - Handles file operations with proper error checking and cleanup Fix CodeQL security issue: prevent logging of sensitive S3 credentials - Add createdInitialIAM flag to track when initial IAM config is created from env vars - Set flag in startS3Service() when new IAM config is successfully written - Update welcome message to inform user of credential creation without exposing secrets - Print only the username (mini) and config file location to user - Never print access keys or secret keys in clear text - Maintain security while keeping user informed of what was created - Addresses CodeQL finding: Clear-text logging of sensitive information * Fix three code review issues in weed mini command 1. Fix deadlock in service startup coordination: - Run blocking service functions (startMaster, startFiler, etc.) in separate goroutines - This allows readyChan to be closed and prevents indefinite blocking - Services now start concurrently instead of sequentially blocking the coordinator 2. Use shared grace.StartDebugServer for consistency: - Replace inline debug server startup with grace.StartDebugServer - Improves code consistency with other commands (master, filer, etc.) - Removes net/http import which is no longer needed 3. Simplify IAM config file cleanup with defer: - Use 'defer f.Close()' instead of multiple f.Close() calls - Ensures file is closed regardless of which code path is taken - Improves robustness and code clarity * fmt * Fix: Remove misleading 'service is ready' logs The previous fix removed 'go' from service function calls but left misleading 'service is ready' log messages. The service helpers now correctly: - Call fn() directly (blocking) instead of 'go fn()' (non-blocking) - Remove the 'service is ready' message that was printed before the service actually started running - Services run as blocking goroutines within the coordinator goroutine, which keeps them alive while the program runs - The readiness channels still work correctly because they're closed when the coordinator finishes waiting for dependencies * Update mini.go * Fix four code review issues in weed mini command 1. Use restrictive file permissions (0600) for IAM config: - Changed from 0644 to 0600 when creating iam_config.json - Prevents world-readable access to sensitive AWS credentials - Protects AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY 2. Remove unused sync.WaitGroup: - Removed WaitGroup that was never waited on - All services run as blocking goroutines in the coordinator - Main goroutine blocks indefinitely with select{} - Removes unnecessary complexity without changing behavior 3. Merge service startup helper functions: - Combined startServiceWithCoordination and startServiceWithoutReady - Made readyChan optional (nil for services without readiness signaling) - Reduces code duplication and improves maintainability - Both services now use single startServiceWithCoordination function 4. Fix admin server readiness check: - Removed misleading timeout channel that never closed at startup - Replaced with simple 2-second sleep before worker startup - startAdminServer() blocks indefinitely, so channel would only close on shutdown - Explicit sleep is clearer about the startup coordination intent * Fix three code quality issues in weed mini command 1. Define volume configuration as named constants: - Added miniVolumeMaxDataVolumeCounts = "0" - Added miniVolumeMinFreeSpace = "1" - Added miniVolumeMinFreeSpacePercent = "1" - Removed local variable assignments in Volume startup - Improves maintainability and documents configuration intent 2. Fix deadlock in startServiceWithCoordination: - Changed from 'defer close(readyChan)' with blocking fn() to running fn() in goroutine - Close readyChan immediately after launching service goroutine - Prevents deadlock where fn() never returns, blocking defer execution - Allows dependent services to start without waiting for blocking call 3. Improve admin server readiness check: - Replaced fixed 2-second sleep with polling the gRPC port - Polls up to 20 times (10 seconds total) with 500ms intervals - Uses net.DialTimeout to check if port is available - Properly handles IPv6 addresses using net.JoinHostPort - Logs progress and warnings about connection status - More robust than sleep against server startup timing variations 4. Add net import for network operations (IPv6 support) Also fixed IAM config file close error handling to properly check error from f.Close() and log any failures, preventing silent data loss on NFS. * Document environment variable setup for S3 credentials Updated welcome message to explain two ways to create S3 credentials: 1. Environment variables (recommended for quick setup): - Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY - Run 'weed mini -dir=/data' - Creates initial 'mini' user credentials automatically 2. Admin UI (for managing multiple users and policies): - Open http://localhost:23646 (Admin UI) - Add identities to create new S3 credentials This gives users clear guidance on the easiest way to get started with S3 credentials while also explaining the more advanced option for multiple users. * Print welcome message after all services are running Moved the welcome message printing from immediately after startMiniServices() to after all services have been started and are ready. This ensures users see the welcome message only after startup is complete, not mixed with startup logs. Changes: - Extract welcome message logic into printWelcomeMessage() function - Call printWelcomeMessage() after startMiniServices() completes - Change message from 'are starting' to 'are running and ready to use' - This provides cleaner startup output without interleaved logs * Wait for all services to complete before printing welcome message The welcome message should only appear after all services are fully running and the worker is connected. This prevents the message from appearing too early before startup logs complete. Changes: - Pass allServicesReady channel through startMiniServices() - Add adminReadyChan to track when admin/worker startup completes - Signal allServicesReady when admin service is fully ready - Wait for allServicesReady in runMini() before printing welcome message - This ensures clean output: startup logs first, then welcome message once ready Now the user sees all startup activity, then a clear welcome message when everything is truly ready to use. * Fix welcome message timing: print after worker is fully started The welcome message was printing too early because allServicesReady was being closed when the Admin service goroutine started, not when it actually completed. The Admin service launches startMiniAdminWithWorker() which is a blocking call that doesn't return until the worker is fully connected. Now allServicesReady is passed through to startMiniWorker() which closes it after the worker successfully starts and connects to the admin server. This ensures the welcome message only appears after: - Master is ready - Volume server is ready - Filer is ready - S3 service is ready - WebDAV service is ready - Admin server is ready - Worker is connected and running All startup logs appear first, then the clean welcome message at the end. * Wait for S3 and WebDAV services to be ready before showing welcome message The welcome message was printing before S3 and WebDAV servers had fully initialized. Now the readiness flow is: 1. Master → ready 2. Volume → ready 3. Filer → ready 4. S3 → ready (signals s3ReadyChan) 5. WebDAV → ready (signals webdavReadyChan) 6. Admin/Worker → starts, then waits for both S3 and WebDAV 7. Welcome message prints (all services truly ready) Changes: - Add s3ReadyChan and webdavReadyChan to service startup - Pass S3 and WebDAV ready channels through to Admin service - Admin/Worker waits for both S3 and WebDAV before closing allServicesReady - This ensures welcome message appears only when all services are operational * Admin service should wait for Filer, S3, and WebDAV to be ready Admin service depends on Filer being operational since it uses the filer for credential storage. It also makes sense to wait for S3 and WebDAV since they are user-facing services that should be ready before Admin. Updated dependencies: - Admin now waits for: Master, Filer, S3, WebDAV - This ensures all critical services are operational before Admin starts - Welcome message will print only after all services including Admin are ready * Add initialization delay for S3 and WebDAV services S3 and WebDAV servers need extra time to fully initialize and start listening after their service functions are launched. Added a 1-second delay after launching S3 and WebDAV goroutines before signaling readiness. This ensures the welcome message doesn't print until both services have emitted their startup logs and are actually serving requests. * Increase service initialization wait times for more reliable startup - Increase S3 and WebDAV initialization delay from 1s to 2s to ensure they emit startup logs before welcome message - Add 1s initialization delay for Filer to ensure it's listening - Increase admin gRPC polling timeout from 10s to 20s to ensure admin server is fully ready - This ensures welcome message prints only after all services are fully initialized and ready to accept requests * Increase service wait time to 10 seconds for reliable startup All services now wait 10 seconds after launching to ensure they are fully initialized and ready before signaling readiness to dependent services. This ensures the welcome message prints only after all services have fully started. * Replace fixed 10s delay with intelligent port polling for service readiness Instead of waiting a fixed 10 seconds for each service, now polls the service port to check if it's actually accepting connections. This eliminates unnecessary waiting and allows services to signal readiness as soon as they're ready. - Polls each service port with up to 30 attempts (6 seconds total) - Each attempt waits 200ms before retrying - Stops polling immediately once service is ready - Falls back gracefully if service is unknown - Significantly faster startup sequence while maintaining reliability * Replace channel-based coordination with HTTP pinging for service readiness Instead of using channels to coordinate service startup, now uses HTTP GET requests to ping each service endpoint to check if it's ready to accept connections. Key changes: - Removed all readiness channels (masterReadyChan, volumeReadyChan, etc.) - Simplified startMiniServices to use sequential HTTP polling for each service - startMiniService now just starts the service with logging - waitForServiceReady uses HTTP client to ping service endpoints (max 6 seconds) - waitForAdminServerReady uses HTTP GET to check admin server availability - startMiniAdminWithWorker and startMiniWorker simplified without channel parameters Benefits: - Cleaner, more straightforward code - HTTP pinging is more reliable than TCP port probing - Services signal readiness through their HTTP endpoints - Eliminates channel synchronization complexity * log level * Remove overly specific comment from volume size limit in welcome message The '(good for small files)' comment is too limiting. The 128MB volume size limit works well for general use cases, not just small files. Simplified the message to just show the value. * Ensure allServicesReady channel is always closed via defer Add 'defer close(allServicesReady)' at the start of startMiniAdminWithWorker to guarantee the channel is closed on ALL exit paths (normal and error). This prevents the caller waiting on <-allServicesReady from ever hanging, while removing the explicit close() at the successful end prevents panic from double-close. This makes the code more robust by: - Guaranteeing channel closure even if worker setup fails - Eliminating the possibility of caller hanging on errors - Following Go defer patterns for resource cleanup * Enhance health check polling for more robust service coordination The service startup already uses HTTP health checks via waitForServiceReady() to verify services are actually accepting connections. This commit improves the health check implementation: Changes: - Elevated success logging to Info level so users see when services become ready - Improved error messages to clarify that health check timeouts are not fatal - Services continue startup even if health checks timeout (they may still work) - Consistent handling of health check results across all services This provides better visibility into service startup while maintaining the existing robust coordination via HTTP pinging rather than just TCP port checks. * Implement stricter error handling for robust mini server startup Apply all PR review feedback to ensure the mini server fails fast and clearly when critical components cannot start: Changes: 1. Remove redundant miniVolumeMinFreeSpacePercent constant - Simplified util.MustParseMinFreeSpace() call to use single parameter 2. Make service readiness checks fatal errors: - Master, Volume, Filer, S3, WebDAV health check failures now return errors - Prevents partially-functional servers from running - Caller can handle errors gracefully instead of continuing with broken state 3. Make admin server readiness fatal: - Admin gRPC availability is critical for worker startup - Use glog.Fatalf to terminate with clear error message 4. Improve IAM config error handling: - Treat all file operation failures (stat, open, write, close) as fatal - Prevents silent failures in S3 credential setup - User gets immediate feedback instead of authentication issues later 5. Use glog.Fatalf for critical worker setup errors: - Failed to create worker directory, task directories, or worker instance - Failed to create admin client or start worker - Ensures mini server doesn't run in broken state This ensures deterministic startup: services succeed completely or fail with clear, actionable error messages for the user. * Make health checks non-fatal for graceful degradation and improve IAM file handling Address PR feedback to make the mini command more resilient for development: 1. Make health check failures non-fatal - Master, Volume, Filer, S3, WebDAV health checks now log warnings but allow startup - Services may still work even if health check endpoints aren't immediately available - Aligns with intent of a dev-focused tool that should be forgiving of timing issues - Only prevents startup if startup coordination or critical errors occur 2. Improve IAM config file handling - Refactored to guarantee file is always closed using separate error variables - Opens file once and handles write/close errors independently - Maintains strict error handling while improving code clarity - All file operation failures still cause fatal errors (as intended) This makes startup more graceful while maintaining critical error handling for fundamental failures like missing directories or configuration errors. * Fix code quality issues in weed mini command - Fix pointer aliasing: use value copy (miniBindIp = miniIp) instead of pointer assignment - Remove misleading error return from waitForServiceReady() function - Simplify health check callers to call waitForServiceReady() directly without error handling - Remove redundant S3 option assignments already set in init() block - Remove unused allServicesReady parameter from startMiniWorker() function * Refactor welcome message to use template strings and add startup delay - Convert welcome message to constant template strings for cleaner code - Separate credentials instructions into dedicated constant - Add 500ms delay after worker startup to allow full initialization before welcome message - Improves output cleanliness by avoiding log interleaving with welcome message * Fix code style issues in weed mini command - Fix indentation in IAM config block (lines 424-432) to align with surrounding code - Remove unused adminServerDone channel that was created but never read * Address code review feedback for robustness and resource management - Use defer f.Close() for IAM file handling to ensure file is closed in all code paths, preventing potential file descriptor leaks - Use 127.0.0.1 instead of miniIp for service readiness checks to ensure checks always target localhost, improving reliability in environments with firewalls or complex network configurations - Simplify error handling in waitForAdminServerReady by using single error return instead of separate write/close error variables Fix function declaration formatting - Separate closing brace of startS3Service from startMiniAdminWithWorker declaration with blank line - Move comment to proper position above function declaration - Run gofmt for consistent formatting * Fix IAM config pointer assignment when file already exists - Add missing miniIamConfig = iamPath assignment when IAM config file already exists - Ensures S3 service is properly pointed to the existing IAM configuration - Retains logging to inform user that existing configuration is being preserved Improve pointer assignments and worker synchronization - Simplify grpcPort and dataDir pointer assignments by directly dereferencing and assigning values instead of taking address of local variables - Replace time.Sleep(500ms) with proper TCP-based polling to wait for worker gRPC port readiness - Add waitForWorkerReady function that polls worker's gRPC port with max 6-second timeout - Add net package import for TCP connection checks - Improves code idiomaticity and synchronization robustness * Refactor and simplify error handling for maintainability - Remove unused error return from startMiniServices (always returned nil) - Update runMini caller to not expect error from startMiniServices - Refactor init() into component-specific helper functions: * initMiniCommonFlags() for common options * initMiniMasterFlags() for master server options * initMiniFilerFlags() for filer server options * initMiniVolumeFlags() for volume server options * initMiniS3Flags() for S3 server options * initMiniWebDAVFlags() for WebDAV server options * initMiniAdminFlags() for admin server options - Significantly improves code readability and maintainability - Each component's flags are now in dedicated, focused functions	4 days ago