Snider/Mining
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ax(node): rename Worker receiver from w to worker

Browse source 
AX Principle 1 — predictable names over short names.
The single-letter receiver `w` is ambiguous; `worker` is self-describing.

Co-Authored-By: Charon <charon@lethean.io>
This commit is contained in:
Claude 2026-04-02 12:59:05 +01:00
parent ddb24545b9
commit f9b2a5dd75
No known key found for this signature in database
GPG key ID: AF404715446AEB41
1 changed files with 42 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

84
pkg/node/worker.go
View file

@ -58,34 +58,34 @@ func NewWorker(node *NodeManager, transport *Transport) *Worker {
}
// worker.SetMinerManager(miningManager)
func (w *Worker) SetMinerManager(manager MinerManager) {
w.minerManager = manager
func (worker *Worker) SetMinerManager(manager MinerManager) {
worker.minerManager = manager
}
// worker.SetProfileManager(profileManager)
func (w *Worker) SetProfileManager(manager ProfileManager) {
w.profileManager = manager
func (worker *Worker) SetProfileManager(manager ProfileManager) {
worker.profileManager = manager
}
// worker.HandleMessage(conn, msg)
// worker.RegisterWithTransport() // registers HandleMessage as the transport handler
func (w *Worker) HandleMessage(conn *PeerConnection, msg *Message) {
func (worker *Worker) HandleMessage(conn *PeerConnection, msg *Message) {
var response *Message
var err error
switch msg.Type {
case MsgPing:
response, err = w.handlePing(msg)
response, err = worker.handlePing(msg)
case MsgGetStats:
response, err = w.handleGetStats(msg)
response, err = worker.handleGetStats(msg)
case MsgStartMiner:
response, err = w.handleStartMiner(msg)
response, err = worker.handleStartMiner(msg)
case MsgStopMiner:
response, err = w.handleStopMiner(msg)
response, err = worker.handleStopMiner(msg)
case MsgGetLogs:
response, err = w.handleGetLogs(msg)
response, err = worker.handleGetLogs(msg)
case MsgDeploy:
response, err = w.handleDeploy(conn, msg)
response, err = worker.handleDeploy(conn, msg)
default:
// Unknown message type - ignore or send error
return
@ -93,7 +93,7 @@ func (w *Worker) HandleMessage(conn *PeerConnection, msg *Message) {
if err != nil {
// Send error response
identity := w.node.GetIdentity()
identity := worker.node.GetIdentity()
if identity != nil {
errMsg, _ := NewErrorMessage(
identity.ID,
@ -117,8 +117,8 @@ func (w *Worker) HandleMessage(conn *PeerConnection, msg *Message) {
}
}
// resp, err := w.handlePing(msg)
func (w *Worker) handlePing(msg *Message) (*Message, error) {
// resp, err := worker.handlePing(msg)
func (worker *Worker) handlePing(msg *Message) (*Message, error) {
var ping PingPayload
if err := msg.ParsePayload(&ping); err != nil {
return nil, fmt.Errorf("invalid ping payload: %w", err)
@ -132,9 +132,9 @@ func (w *Worker) handlePing(msg *Message) (*Message, error) {
return msg.Reply(MsgPong, pong)
}
// resp, err := w.handleGetStats(msg)
func (w *Worker) handleGetStats(msg *Message) (*Message, error) {
identity := w.node.GetIdentity()
// resp, err := worker.handleGetStats(msg)
func (worker *Worker) handleGetStats(msg *Message) (*Message, error) {
identity := worker.node.GetIdentity()
if identity == nil {
return nil, fmt.Errorf("node identity not initialized")
}
@ -143,11 +143,11 @@ func (w *Worker) handleGetStats(msg *Message) (*Message, error) {
NodeID: identity.ID,
NodeName: identity.Name,
Miners: []MinerStatsItem{},
Uptime: int64(time.Since(w.startTime).Seconds()),
Uptime: int64(time.Since(worker.startTime).Seconds()),
}
if w.minerManager != nil {
miners := w.minerManager.ListMiners()
if worker.minerManager != nil {
miners := worker.minerManager.ListMiners()
for _, miner := range miners {
minerStats, err := miner.GetStats()
if err != nil {
@ -196,9 +196,9 @@ func convertMinerStats(miner MinerInstance, rawStats interface{}) MinerStatsItem
return item
}
// resp, err := w.handleStartMiner(msg)
func (w *Worker) handleStartMiner(msg *Message) (*Message, error) {
if w.minerManager == nil {
// resp, err := worker.handleStartMiner(msg)
func (worker *Worker) handleStartMiner(msg *Message) (*Message, error) {
if worker.minerManager == nil {
return nil, fmt.Errorf("miner manager not configured")
}
@ -216,8 +216,8 @@ func (w *Worker) handleStartMiner(msg *Message) (*Message, error) {
var config interface{}
if payload.Config != nil {
config = payload.Config
} else if w.profileManager != nil {
profile, err := w.profileManager.GetProfile(payload.ProfileID)
} else if worker.profileManager != nil {
profile, err := worker.profileManager.GetProfile(payload.ProfileID)
if err != nil {
return nil, fmt.Errorf("profile not found: %s", payload.ProfileID)
}
@ -227,7 +227,7 @@ func (w *Worker) handleStartMiner(msg *Message) (*Message, error) {
}
// Start the miner
miner, err := w.minerManager.StartMiner(payload.MinerType, config)
miner, err := worker.minerManager.StartMiner(payload.MinerType, config)
if err != nil {
ack := MinerAckPayload{
Success: false,
@ -243,9 +243,9 @@ func (w *Worker) handleStartMiner(msg *Message) (*Message, error) {
return msg.Reply(MsgMinerAck, ack)
}
// resp, err := w.handleStopMiner(msg)
func (w *Worker) handleStopMiner(msg *Message) (*Message, error) {
if w.minerManager == nil {
// resp, err := worker.handleStopMiner(msg)
func (worker *Worker) handleStopMiner(msg *Message) (*Message, error) {
if worker.minerManager == nil {
return nil, fmt.Errorf("miner manager not configured")
}
@ -254,7 +254,7 @@ func (w *Worker) handleStopMiner(msg *Message) (*Message, error) {
return nil, fmt.Errorf("invalid stop miner payload: %w", err)
}
err := w.minerManager.StopMiner(payload.MinerName)
err := worker.minerManager.StopMiner(payload.MinerName)
ack := MinerAckPayload{
Success: err == nil,
MinerName: payload.MinerName,
@ -266,9 +266,9 @@ func (w *Worker) handleStopMiner(msg *Message) (*Message, error) {
return msg.Reply(MsgMinerAck, ack)
}
// resp, err := w.handleGetLogs(msg)
func (w *Worker) handleGetLogs(msg *Message) (*Message, error) {
if w.minerManager == nil {
// resp, err := worker.handleGetLogs(msg)
func (worker *Worker) handleGetLogs(msg *Message) (*Message, error) {
if worker.minerManager == nil {
return nil, fmt.Errorf("miner manager not configured")
}
@ -283,7 +283,7 @@ func (w *Worker) handleGetLogs(msg *Message) (*Message, error) {
payload.Lines = maxLogLines
}
miner, err := w.minerManager.GetMiner(payload.MinerName)
miner, err := worker.minerManager.GetMiner(payload.MinerName)
if err != nil {
return nil, fmt.Errorf("miner not found: %s", payload.MinerName)
}
@ -299,8 +299,8 @@ func (w *Worker) handleGetLogs(msg *Message) (*Message, error) {
return msg.Reply(MsgLogs, logs)
}
// resp, err := w.handleDeploy(conn, msg)
func (w *Worker) handleDeploy(conn *PeerConnection, msg *Message) (*Message, error) {
// resp, err := worker.handleDeploy(conn, msg)
func (worker *Worker) handleDeploy(conn *PeerConnection, msg *Message) (*Message, error) {
var payload DeployPayload
if err := msg.ParsePayload(&payload); err != nil {
return nil, fmt.Errorf("invalid deploy payload: %w", err)
@ -322,7 +322,7 @@ func (w *Worker) handleDeploy(conn *PeerConnection, msg *Message) (*Message, err
switch bundle.Type {
case BundleProfile:
if w.profileManager == nil {
if worker.profileManager == nil {
return nil, fmt.Errorf("profile manager not configured")
}
@ -338,7 +338,7 @@ func (w *Worker) handleDeploy(conn *PeerConnection, msg *Message) (*Message, err
return nil, fmt.Errorf("invalid profile data JSON: %w", err)
}
if err := w.profileManager.SaveProfile(profile); err != nil {
if err := worker.profileManager.SaveProfile(profile); err != nil {
ack := DeployAckPayload{
Success: false,
Name: payload.Name,
@ -372,12 +372,12 @@ func (w *Worker) handleDeploy(conn *PeerConnection, msg *Message) (*Message, err
}
// If the bundle contained a profile config, save it
if len(profileData) > 0 && w.profileManager != nil {
if len(profileData) > 0 && worker.profileManager != nil {
var profile interface{}
if err := json.Unmarshal(profileData, &profile); err != nil {
logging.Warn("failed to parse profile from miner bundle", logging.Fields{"error": err})
} else {
if err := w.profileManager.SaveProfile(profile); err != nil {
if err := worker.profileManager.SaveProfile(profile); err != nil {
logging.Warn("failed to save profile from miner bundle", logging.Fields{"error": err})
}
}
@ -403,6 +403,6 @@ func (w *Worker) handleDeploy(conn *PeerConnection, msg *Message) (*Message, err
}
// worker.RegisterWithTransport() // call once after setup to start handling messages
func (w *Worker) RegisterWithTransport() {
w.transport.OnMessage(w.HandleMessage)
func (worker *Worker) RegisterWithTransport() {
worker.transport.OnMessage(worker.HandleMessage)
}