Refactor codebase by improving readability across multiple files

Author: l00pss

commands.go

@@ -1,93 +1,34 @@
-/*
-Package redkit provides a comprehensive Redis-compatible server implementation.
-
-This file defines all Redis command types and their registration helper functions.
-The commands are organized into functional categories following Redis documentation.
-
-Command Categories:
-- Connection Commands: Basic server communication (PING, ECHO, QUIT)
-- String Commands: String operations (GET, SET, INCR, APPEND, etc.)
-- Hash Commands: Hash table operations (HGET, HSET, HKEYS, etc.)
-- List Commands: List operations (LPUSH, RPOP, LRANGE, etc.)
-- Set Commands: Set operations (SADD, SREM, SMEMBERS, etc.)
-- Sorted Set Commands: Ordered set operations (ZADD, ZRANGE, ZSCORE, etc.)
-- Stream Commands: Stream data structure operations (XADD, XREAD, etc.)
-- Bitmap Commands: Bit manipulation (BITCOUNT, SETBIT, GETBIT, etc.)
-- HyperLogLog Commands: Probabilistic cardinality estimation (PFADD, PFCOUNT, etc.)
-- Geospatial Commands: Geographic operations (GEOADD, GEORADIUS, etc.)
-- JSON Commands: JSON data operations (JSON.GET, JSON.SET, etc.)
-- Search Commands: Full-text search (FT.SEARCH, FT.CREATE, etc.)
-- Time Series Commands: Time-series data (TS.ADD, TS.RANGE, etc.)
-- Vector Set Commands: Vector similarity operations (VADD, VSIM, etc.)
-- Pub/Sub Commands: Message publishing/subscribing (PUBLISH, SUBSCRIBE, etc.)
-- Transaction Commands: Atomic operations (MULTI, EXEC, WATCH, etc.)
-- Scripting Commands: Lua script execution (EVAL, EVALSHA, etc.)
-- Server Commands: Server management (INFO, CONFIG, SAVE, etc.)
-- Cluster Commands: Redis cluster operations (CLUSTER, ASKING, etc.)
-- Generic Commands: Key management (DEL, EXISTS, EXPIRE, TTL, etc.)
-
-Usage Example:
-
-	server := redkit.NewServer()
-
-	// Register custom GET handler
-	server.registerGetHandler(func(conn *Connection, cmd *Command) RedisValue {
-		// Custom GET implementation
-		return RedisValue{Type: SimpleString, Str: "value"}
-	})
-
-	// Start server
-	server.ListenAndServe(":6379")
-
-Each command has a corresponding registration helper function that follows the pattern:
-
-	register{CommandName}Handler(f func(conn *Connection, cmd *Command) RedisValue)
-
-This allows for easy customization and extension of command behavior while maintaining
-Redis protocol compatibility.
-*/
 package redkit
 
-// CommandType represents Redis command names as typed string constants
-// This ensures type safety and provides intellisense support for command names
+// CommandType represents Redis command names
 type CommandType string
 
-/*
-Redis Command Type Constants
-
-All Redis commands are defined as strongly-typed constants to prevent typos
-and provide IDE autocompletion. Commands are organized by functional category
-matching the official Redis documentation structure.
-
-The constants follow the exact Redis command names (case-sensitive) to ensure
-protocol compatibility.
-*/
 const (
-	// Connection Commands - Basic server communication
+	// Connection Commands
 	PING CommandType = "PING" // Test server connectivity
 	ECHO CommandType = "ECHO" // Echo the given string
 	QUIT CommandType = "QUIT" // Close the connection
 	HELP CommandType = "HELP" // Show help information
 
-	// String Commands - Operations on string values
-	APPEND      CommandType = "APPEND"      // Append a value to a key
-	DECR        CommandType = "DECR"        // Decrement the integer value of a key by 1
-	DECRBY      CommandType = "DECRBY"      // Decrement the integer value of a key by the given amount
-	DELEX       CommandType = "DELEX"       // Delete key based on value comparison
-	DIGEST      CommandType = "DIGEST"      // Return hash digest of a string value
-	GET         CommandType = "GET"         // Get the value of a key
-	GETDEL      CommandType = "GETDEL"      // Get the value of a key and delete the key
-	GETEX       CommandType = "GETEX"       // Get the value of a key and set its expiration
-	GETRANGE    CommandType = "GETRANGE"    // Get a substring of the string stored at a key
-	GETSET      CommandType = "GETSET"      // Set the value of a key and return its old value
-	INCR        CommandType = "INCR"        // Increment the integer value of a key by 1
-	INCRBY      CommandType = "INCRBY"      // Increment the integer value of a key by the given amount
-	INCRBYFLOAT CommandType = "INCRBYFLOAT" // Increment the float value of a key by the given amount
-	LCS         CommandType = "LCS"         // Find the longest common substring
-	MGET        CommandType = "MGET"        // Get the values of all the given keys
-	MSET        CommandType = "MSET"        // Set multiple keys to multiple values
-	MSETEX      CommandType = "MSETEX"      // Set multiple keys with expiration time
-	MSETNX      CommandType = "MSETNX"      // Set multiple keys to multiple values, only if none exist
+	// String Commands
+	APPEND      CommandType = "APPEND"
+	DECR        CommandType = "DECR"
+	DECRBY      CommandType = "DECRBY"
+	DELEX       CommandType = "DELEX"
+	DIGEST      CommandType = "DIGEST"
+	GET         CommandType = "GET"
+	GETDEL      CommandType = "GETDEL"
+	GETEX       CommandType = "GETEX"
+	GETRANGE    CommandType = "GETRANGE"
+	GETSET      CommandType = "GETSET"
+	INCR        CommandType = "INCR"
+	INCRBY      CommandType = "INCRBY"
+	INCRBYFLOAT CommandType = "INCRBYFLOAT"
+	LCS         CommandType = "LCS"
+	MGET        CommandType = "MGET"
+	MSET        CommandType = "MSET"
+	MSETEX      CommandType = "MSETEX"
+	MSETNX      CommandType = "MSETNX"
 	PSETEX      CommandType = "PSETEX"
 	SET         CommandType = "SET"
 	SETEX       CommandType = "SETEX"
@@ -440,23 +381,6 @@ const (
 	WAITAOF     CommandType = "WAITAOF"
 )
 
-/*
-Default Command Handlers
-
-registerDefaultHandlers sets up the basic Redis protocol commands that are
-essential for client connectivity and server interaction. These handlers
-implement the minimum functionality required for Redis compatibility:
-
-- PING: Connectivity testing with optional message echo
-- ECHO: Simple string echo for testing
-- HELP: Basic command information
-- QUIT: Graceful connection termination
-
-Custom implementations can override these by registering new handlers
-with the same command names, or extend functionality by registering
-additional commands.
-*/
-
 // registerDefaultHandlers registers the built-in Redis commands
 func (s *Server) registerDefaultHandlers() {
 	// PING command
@@ -494,48 +418,22 @@ func (s *Server) registerDefaultHandlers() {
 	})
 }
 
-/*
-Command Registration Helper Functions
-
-These functions provide a convenient way to register custom handlers for Redis commands.
-Each function follows the pattern: register{CommandName}Handler(handlerFunc)
-
-The handler function signature is always:
-	func(conn *Connection, cmd *Command) RedisValue
-
-Where:
-- conn: The client connection context
-- cmd: The parsed command with arguments
-- RedisValue: The response to send back to the client
-
-Example usage:
-	server.registerGetHandler(func(conn *Connection, cmd *Command) RedisValue {
-		key := cmd.Args[0]
-		value := myStorage.Get(key)
-		return RedisValue{Type: BulkString, Bulk: []byte(value)}
-	})
-*/
-
 // registerPingHandler registers a custom handler for the PING command
-// PING [message] - Test connectivity and optionally echo a message
 func (s *Server) registerPingHandler(f func(conn *Connection, cmd *Command) RedisValue) {
 	s.RegisterCommandFunc(string(PING), f)
 }
 
 // registerEchoHandler registers a custom handler for the ECHO command
-// ECHO message - Return the given string
 func (s *Server) registerEchoHandler(f func(conn *Connection, cmd *Command) RedisValue) {
 	s.RegisterCommandFunc(string(ECHO), f)
 }
 
 // registerQuitHandler registers a custom handler for the QUIT command
-// QUIT - Close the connection
 func (s *Server) registerQuitHandler(f func(conn *Connection, cmd *Command) RedisValue) {
 	s.RegisterCommandFunc(string(QUIT), f)
 }
 
 // registerHelpHandler registers a custom handler for the HELP command
-// HELP - Show available commands and their descriptions
 func (s *Server) registerHelpHandler(f func(conn *Connection, cmd *Command) RedisValue) {
 	s.RegisterCommandFunc(string(HELP), f)
 }

connection.go

@@ -1,61 +1,3 @@
-/*
-Package redkit implements client connection management for Redis-compatible servers.
-
-This file provides the Connection type and associated methods for managing
-individual client connections throughout their lifecycle.
-
-Core Responsibilities:
-- TCP/TLS connection wrapping and management
-- Buffered I/O for optimal Redis protocol performance
-- Thread-safe connection state tracking and transitions
-- Context-based cancellation and resource cleanup
-- Connection metadata and network address access
-
-Connection Lifecycle:
-1. Connection creation and initialization (StateNew)
-2. Active command processing (StateActive)
-3. Idle waiting between commands (StateIdle)
-4. Graceful termination and cleanup (StateClosed)
-
-Thread Safety:
-The Connection type is designed for concurrent access with proper synchronization:
-- Atomic operations for state management
-- Mutex protection for shared fields (lastUsed)
-- sync.Once for safe connection cleanup
-- Context cancellation for coordinated shutdown
-
-Performance Optimizations:
-- Buffered readers and writers to minimize syscalls
-- Atomic state tracking to avoid lock contention
-- Efficient network address caching
-- Minimal allocation overhead in hot paths
-
-Integration:
-Connection instances are typically created by the Server during client
-connection acceptance and managed throughout the command processing
-lifecycle. They provide the necessary context for command handlers
-to access client-specific state and network information.
-
-Usage Example:
-
-	// Connection is typically created by the server
-	conn := &Connection{
-		conn:     netConn,
-		reader:   bufio.NewReader(netConn),
-		writer:   bufio.NewWriter(netConn),
-		server:   server,
-		ctx:      ctx,
-		cancel:   cancelFunc,
-		lastUsed: time.Now(),
-	}
-
-	// Command handlers can access connection context
-	func myHandler(conn *Connection, cmd *Command) RedisValue {
-		clientAddr := conn.RemoteAddr()
-		state := conn.GetState()
-		// Process command with connection context
-	}
-*/
 package redkit
 
 import (
@@ -67,67 +9,21 @@ import (
 	"time"
 )
 
-/*
-Client Connection Management
-
-Connection wraps a network connection with Redis protocol-specific
-functionality including buffered I/O, state tracking, and lifecycle management.
-
-Fields Overview:
-- conn: Underlying TCP/TLS network connection
-- reader/writer: Buffered I/O for efficient Redis protocol handling
-- server: Reference to parent server for configuration and hooks
-- state: Atomic connection state (StateNew/Active/Idle/Closed)
-- closeOnce: Ensures connection is closed exactly once (thread-safe)
-- ctx/cancel: Context for coordinated cancellation and cleanup
-- mu: Protects shared mutable fields like lastUsed
-- lastUsed: Timestamp for idle timeout management
-
-Thread Safety:
-All public methods are thread-safe and can be called concurrently
-from multiple goroutines. State transitions are atomic and properly
-synchronized with connection hooks and cleanup operations.
-
-Resource Management:
-The Connection automatically manages its resources and integrates
-with the server's connection tracking for proper cleanup during
-shutdown scenarios.
-*/
-
 // Connection represents a client connection to the Redis server
 type Connection struct {
-	conn      net.Conn           // Underlying network connection
-	reader    *bufio.Reader      // Buffered reader for efficient parsing
-	writer    *bufio.Writer      // Buffered writer for response batching
-	server    *Server            // Parent server reference
-	state     atomic.Int32       // Current connection state (atomic)
-	closeOnce sync.Once          // Ensures single cleanup execution
-	ctx       context.Context    // Connection context for cancellation
-	cancel    context.CancelFunc // Context cancellation function
-	mu        sync.RWMutex       // Protects mutable fields
-	lastUsed  time.Time          // Last activity timestamp for idle detection
+	conn      net.Conn
+	reader    *bufio.Reader
+	writer    *bufio.Writer
+	server    *Server
+	state     atomic.Int32
+	closeOnce sync.Once
+	ctx       context.Context
+	cancel    context.CancelFunc
+	mu        sync.RWMutex
+	lastUsed  time.Time
 }
 
-/*
-Connection State Management
-
-These methods manage connection state transitions and provide
-thread-safe access to connection status information.
-*/
-
 // setState updates the connection state
-// Atomically updates the connection state and triggers the server's
-// connection state hook if configured. This enables monitoring and
-// metrics collection for connection lifecycle events.
-//
-// State transitions follow the pattern:
-// StateNew -> StateActive -> StateIdle -> StateClosed
-//
-//	↑         ↓
-//	└─────────┘ (can cycle)
-//
-// Parameters:
-// - state: New connection state to set
 func (c *Connection) setState(state ConnState) {
 	c.state.Store(int32(state))
 	if c.server.ConnStateHook != nil {
@@ -136,17 +32,6 @@ func (c *Connection) setState(state ConnState) {
 }
 
 // Close closes the connection
-// Performs thread-safe connection cleanup exactly once, regardless of
-// how many times it's called. The cleanup process includes:
-// 1. Setting connection state to StateClosed
-// 2. Cancelling the connection context (stops background operations)
-// 3. Closing the underlying network connection
-//
-// This method is safe to call multiple times and from multiple goroutines.
-// Subsequent calls after the first will be no-ops.
-//
-// Returns:
-// - error: Network connection close error, if any
 func (c *Connection) Close() error {
 	var err error
 	c.closeOnce.Do(func() {
@@ -158,40 +43,16 @@ func (c *Connection) Close() error {
 }
 
 // GetState returns the current connection state
-// Thread-safe method to query the current state without triggering
-// any state transitions or side effects. Useful for monitoring,
-// logging, and conditional logic based on connection status.
-//
-// Returns:
-// - ConnState: Current connection state (StateNew/Active/Idle/Closed)
 func (c *Connection) GetState() ConnState {
 	return ConnState(c.state.Load())
 }
 
-/*
-Network Address Access
-
-These methods provide access to the connection's network endpoints
-for logging, monitoring, and access control purposes.
-*/
-
 // RemoteAddr returns the remote network address
-// Provides access to the client's network address for logging,
-// access control, and monitoring purposes. The address format
-// depends on the network type (TCP: "IP:port", Unix: socket path).
-//
-// Returns:
-// - net.Addr: Client's network address
 func (c *Connection) RemoteAddr() net.Addr {
 	return c.conn.RemoteAddr()
 }
 
 // LocalAddr returns the local network address
-// Provides access to the server's local address that accepted
-// this connection. Useful for multi-interface servers and logging.
-//
-// Returns:
-// - net.Addr: Server's local network address for this connection
 func (c *Connection) LocalAddr() net.Addr {
 	return c.conn.LocalAddr()
 }