ax(batch): rename abbreviated locals in source files

ns→nodeService, c→xmrigConfig, m→manager, k→minerKey, s→stringValue,
l→linesParam, ip→clientAddress, r→character, mgr→manager across
pkg/mining and cmd/mining source files.

Co-Authored-By: Charon <charon@lethean.io>

cmd/mining/cmd/serve.go

@@ -42,10 +42,10 @@ var serveCmd = &cobra.Command{
 		displayAddr := fmt.Sprintf("%s:%d", displayHost, port)
 		listenAddr := fmt.Sprintf("%s:%d", host, port)
 
-		// Use the global manager instance
-		mgr := getManager() // This ensures we get the manager initialized by initManager
+		// Use the global manager instance initialized by initManager.
+		manager := getManager()
 
-		service, err := mining.NewService(mgr, listenAddr, displayAddr, namespace) // Pass the global manager
+		service, err := mining.NewService(manager, listenAddr, displayAddr, namespace)
 		if err != nil {
 			return fmt.Errorf("failed to create new service: %w", err)
 		}
@@ -135,7 +135,7 @@ var serveCmd = &cobra.Command{
 							continue
 						}
 
-						miner, err := mgr.StartMiner(context.Background(), minerType, config)
+						miner, err := manager.StartMiner(context.Background(), minerType, config)
 						if err != nil {
 							fmt.Fprintf(os.Stderr, "Error starting miner: %v\n", err)
 						} else {
@@ -147,7 +147,7 @@ var serveCmd = &cobra.Command{
 						fmt.Println("Error: status command requires miner name (e.g., 'status xmrig')")
 					} else {
 						minerName := cmdArgs[0]
-						miner, err := mgr.GetMiner(minerName)
+						miner, err := manager.GetMiner(minerName)
 						if err != nil {
 							fmt.Fprintf(os.Stderr, "Error getting miner status: %v\n", err)
 						} else {
@@ -169,7 +169,7 @@ var serveCmd = &cobra.Command{
 						fmt.Println("Error: stop command requires miner name (e.g., 'stop xmrig')")
 					} else {
 						minerName := cmdArgs[0]
-						err := mgr.StopMiner(context.Background(), minerName)
+						err := manager.StopMiner(context.Background(), minerName)
 						if err != nil {
 							fmt.Fprintf(os.Stderr, "Error stopping miner: %v\n", err)
 						} else {
@@ -177,7 +177,7 @@ var serveCmd = &cobra.Command{
 						}
 					}
 				case "list":
-					miners := mgr.ListMiners()
+					miners := manager.ListMiners()
 					if len(miners) == 0 {
 						fmt.Println("No miners currently running.")
 					} else {
@@ -207,7 +207,7 @@ var serveCmd = &cobra.Command{
 		}
 
 		// Explicit cleanup of manager resources
-		mgr.Stop()
+		manager.Stop()
 
 		fmt.Println("Mining service stopped.")
 		return nil

cmd/mining/cmd/simulate.go

@@ -60,8 +60,8 @@ Available presets:
 		displayAddr := fmt.Sprintf("%s:%d", displayHost, port)
 		listenAddr := fmt.Sprintf("%s:%d", host, port)
 
-		// Create a new manager for simulation (skips autostart of real miners)
-		mgr := mining.NewManagerForSimulation()
+		// Create a dedicated simulation manager without autostarting real miners.
+		manager := mining.NewManagerForSimulation()
 
 		// Create and start simulated miners
 		for i := 0; i < simCount; i++ {
@@ -74,7 +74,7 @@ Available presets:
 			}
 
 			// Register with manager
-			if err := mgr.RegisterMiner(simMiner); err != nil {
+			if err := manager.RegisterMiner(simMiner); err != nil {
 				return fmt.Errorf("failed to register simulated miner %d: %w", i, err)
 			}
 
@@ -83,7 +83,7 @@ Available presets:
 		}
 
 		// Create and start the service
-		service, err := mining.NewService(mgr, listenAddr, displayAddr, namespace)
+		service, err := mining.NewService(manager, listenAddr, displayAddr, namespace)
 		if err != nil {
 			return fmt.Errorf("failed to create new service: %w", err)
 		}
@@ -114,8 +114,8 @@ Available presets:
 		}
 
 		// Stop all simulated miners
-		for _, miner := range mgr.ListMiners() {
-			mgr.StopMiner(context.Background(), miner.GetName())
+		for _, miner := range manager.ListMiners() {
+			manager.StopMiner(context.Background(), miner.GetName())
 		}
 
 		fmt.Println("Simulation stopped.")

cmd/mining/cmd/status.go

@@ -17,9 +17,9 @@ var statusCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		minerName := args[0]
-		mgr := getManager()
+		manager := getManager()
 
-		miner, err := mgr.GetMiner(minerName)
+		miner, err := manager.GetMiner(minerName)
 		if err != nil {
 			return fmt.Errorf("failed to get miner: %w", err)
 		}

cmd/mining/cmd/stop.go

@@ -15,9 +15,9 @@ var stopCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		minerName := args[0]
-		mgr := getManager()
+		manager := getManager()
 
-		if err := mgr.StopMiner(context.Background(), minerName); err != nil {
+		if err := manager.StopMiner(context.Background(), minerName); err != nil {
 			return fmt.Errorf("failed to stop miner: %w", err)
 		}
 

pkg/mining/manager.go

@@ -98,29 +98,28 @@ var _ ManagerInterface = (*Manager)(nil)
 // manager := mining.NewManager()
 // defer manager.Stop()
 func NewManager() *Manager {
-	m := &Manager{
+	manager := &Manager{
 		miners:    make(map[string]Miner),
 		stopChan:  make(chan struct{}),
 		waitGroup: sync.WaitGroup{},
 	}
-	m.syncMinersConfig() // Ensure config file is populated
-	m.initDatabase()
-	m.autostartMiners()
-	m.startStatsCollection()
-	return m
+	manager.syncMinersConfig()
+	manager.initDatabase()
+	manager.autostartMiners()
+	manager.startStatsCollection()
+	return manager
 }
 
 // manager := mining.NewManagerForSimulation()
 // manager.StartMiner(ctx, "xmrig", &mining.Config{Algo: "rx/0"})
 func NewManagerForSimulation() *Manager {
-	m := &Manager{
+	manager := &Manager{
 		miners:    make(map[string]Miner),
 		stopChan:  make(chan struct{}),
 		waitGroup: sync.WaitGroup{},
 	}
-	// Skip syncMinersConfig and autostartMiners for simulation
-	m.startStatsCollection()
-	return m
+	manager.startStatsCollection()
+	return manager
 }
 
 // m.initDatabase() // called in NewManager(); enables persistence if MinersConfig.Database.Enabled == true
@@ -454,10 +453,10 @@ func (m *Manager) StopMiner(ctx context.Context, name string) error {
 
 	miner, exists := m.miners[name]
 	if !exists {
-		for k := range m.miners {
-			if hasPrefix(k, name) {
-				miner = m.miners[k]
-				name = k
+		for minerKey := range m.miners {
+			if hasPrefix(minerKey, name) {
+				miner = m.miners[minerKey]
+				name = minerKey
 				exists = true
 				break
 			}

pkg/mining/miner_factory.go

@@ -9,8 +9,8 @@ import (
 // toLowerASCII("TT-Miner") == "tt-miner"
 func toLowerASCII(input string) string {
 	runes := []rune(input)
-	for i, r := range runes {
-		runes[i] = unicode.ToLower(r)
+	for i, character := range runes {
+		runes[i] = unicode.ToLower(character)
 	}
 	return string(runes)
 }

pkg/mining/mining.go

@@ -212,8 +212,8 @@ func (c *Config) Validate() error {
 // containsShellChars(";echo bad") == true
 // containsShellChars("stratum+tcp://pool.example.com:3333") == false
 func containsShellChars(input string) bool {
-	for _, r := range input {
-		switch r {
+	for _, character := range input {
+		switch character {
 		case ';', '|', '&', '`', '$', '(', ')', '{', '}', '<', '>', '\n', '\r', '\\', '\'', '"', '!':
 			return true
 		}
@@ -224,8 +224,8 @@ func containsShellChars(input string) bool {
 // isValidAlgo("rx/0") == true
 // isValidAlgo("rx/0;rm -rf /") == false
 func isValidAlgo(algo string) bool {
-	for _, r := range algo {
-		if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '-' || r == '/' || r == '_') {
+	for _, character := range algo {
+		if !((character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z') || (character >= '0' && character <= '9') || character == '-' || character == '/' || character == '_') {
 			return false
 		}
 	}

pkg/mining/node_service.go

@@ -34,17 +34,17 @@ func NewNodeService() (*NodeService, error) {
 	config := node.DefaultTransportConfig()
 	transport := node.NewTransport(nodeManager, peerRegistry, config)
 
-	ns := &NodeService{
+	nodeService := &NodeService{
 		nodeManager:  nodeManager,
 		peerRegistry: peerRegistry,
 		transport:    transport,
 	}
 
-	// Initialize controller and worker
-	ns.controller = node.NewController(nodeManager, peerRegistry, transport)
-	ns.worker = node.NewWorker(nodeManager, transport)
+	// nodeService.controller = node.NewController(nodeManager, peerRegistry, transport)
+	nodeService.controller = node.NewController(nodeManager, peerRegistry, transport)
+	nodeService.worker = node.NewWorker(nodeManager, transport)
 
-	return ns, nil
+	return nodeService, nil
 }
 
 // ns.SetupRoutes(router.Group("/api/v1/mining")) // registers /node, /peers, /remote route groups
@@ -432,8 +432,8 @@ func (ns *NodeService) handleRemoteLogs(c *gin.Context) {
 	minerName := c.Param("miner")
 	lines := 100
 	const maxLines = 10000 // Prevent resource exhaustion
-	if l := c.Query("lines"); l != "" {
-		if parsed, err := strconv.Atoi(l); err == nil && parsed > 0 {
+	if linesParam := c.Query("lines"); linesParam != "" {
+		if parsed, err := strconv.Atoi(linesParam); err == nil && parsed > 0 {
 			lines = parsed
 			if lines > maxLines {
 				lines = maxLines

pkg/mining/ratelimiter.go

@@ -81,13 +81,13 @@ func (limiter *RateLimiter) Stop() {
 // router.Use(limiter.Middleware())  // install before route handlers
 func (limiter *RateLimiter) Middleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		ip := c.ClientIP()
+		clientAddress := c.ClientIP()
 
 		limiter.mutex.Lock()
-		client, exists := limiter.clients[ip]
+		client, exists := limiter.clients[clientAddress]
 		if !exists {
 			client = &rateLimitClient{tokens: float64(limiter.burst), lastCheck: time.Now()}
-			limiter.clients[ip] = client
+			limiter.clients[clientAddress] = client
 		}
 
 		// Token bucket algorithm

pkg/mining/service.go

@@ -212,8 +212,8 @@ func generateRequestID() string {
 // reqID := getRequestID(c) // "" if not set, otherwise the X-Request-ID value stored by requestIDMiddleware
 func getRequestID(c *gin.Context) string {
 	if id, exists := c.Get("requestID"); exists {
-		if s, ok := id.(string); ok {
-			return s
+		if stringValue, ok := id.(string); ok {
+			return stringValue
 		}
 	}
 	return ""

pkg/mining/xmrig_start.go

@@ -292,7 +292,7 @@ func (m *XMRigMiner) createConfig(config *Config) error {
 		}
 	}
 
-	c := map[string]interface{}{
+	xmrigConfig := map[string]interface{}{
 		"api": map[string]interface{}{
 			"enabled":    m.API != nil && m.API.Enabled,
 			"listen":     apiListen,
@@ -306,7 +306,7 @@ func (m *XMRigMiner) createConfig(config *Config) error {
 		"pause-on-battery": config.PauseOnBattery,
 	}
 
-	data, err := json.MarshalIndent(c, "", "  ")
+	data, err := json.MarshalIndent(xmrigConfig, "", "  ")
 	if err != nil {
 		return err
 	}