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

ax(batch): expand abbreviated local variables inside function bodies

Browse source 
Applies AX principle 1 to local variables in function bodies:
d->entry (dir entries), p->point (hashrate points), f->zipEntry/entryReader
(zip files), r->zipReader, gzr->gzipReader, f->outputFile (tar files),
k,v->key,value (map iteration), p->pattern (dangerous patterns),
f->fieldSet (logging fields).

Co-Authored-By: Charon <charon@lethean.io>
This commit is contained in:
Claude 2026-04-02 18:29:11 +01:00
parent 0d1b20e177
commit 50f4310ba8
No known key found for this signature in database
GPG key ID: AF404715446AEB41
4 changed files with 45 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
pkg/logging/logger.go
View file

@ -134,11 +134,11 @@ func (logger *Logger) log(level Level, msg string, fields Fields) {
// Add fields if present
if len(fields) > 0 {
builder.WriteString(" |")
for k, v := range fields {
for key, value := range fields {
builder.WriteString(" ")
builder.WriteString(k)
builder.WriteString(key)
builder.WriteString("=")
builder.WriteString(fmt.Sprintf("%v", v))
builder.WriteString(fmt.Sprintf("%v", value))
}
}
@ -192,9 +192,9 @@ func mergeFields(fields []Fields) Fields {
return nil
}
result := make(Fields)
for _, f := range fields {
for k, v := range f {
result[k] = v
for _, fieldSet := range fields {
for key, value := range fieldSet {
result[key] = value
}
}
return result

70
pkg/mining/miner.go
View file

@ -344,17 +344,17 @@ func (b *BaseMiner) findMinerBinary() (string, error) {
if _, err := os.Stat(baseInstallPath); err == nil {
dirs, err := os.ReadDir(baseInstallPath)
if err == nil {
for _, d := range dirs {
if d.IsDir() && strings.HasPrefix(d.Name(), b.ExecutableName+"-") {
for _, entry := range dirs {
if entry.IsDir() && strings.HasPrefix(entry.Name(), b.ExecutableName+"-") {
// Extract version string, e.g., "xmrig-6.24.0" -> "6.24.0"
versionStr := strings.TrimPrefix(d.Name(), b.ExecutableName+"-")
versionStr := strings.TrimPrefix(entry.Name(), b.ExecutableName+"-")
currentVersion := parseVersion(versionStr)
if highestVersionDir == "" || compareVersions(currentVersion, highestVersion) > 0 {
highestVersion = currentVersion
highestVersionDir = d.Name()
highestVersionDir = entry.Name()
}
versionedPath := filepath.Join(baseInstallPath, d.Name())
versionedPath := filepath.Join(baseInstallPath, entry.Name())
fullPath := filepath.Join(versionedPath, executableName)
searchedPaths = append(searchedPaths, fullPath)
}
@ -475,11 +475,11 @@ func (b *BaseMiner) ReduceHashrateHistory(now time.Time) {
var newHighResHistory []HashratePoint
cutoff := now.Add(-HighResolutionDuration)
for _, p := range b.HashrateHistory {
if p.Timestamp.Before(cutoff) {
pointsToAggregate = append(pointsToAggregate, p)
for _, point := range b.HashrateHistory {
if point.Timestamp.Before(cutoff) {
pointsToAggregate = append(pointsToAggregate, point)
} else {
newHighResHistory = append(newHighResHistory, p)
newHighResHistory = append(newHighResHistory, point)
}
}
// Force reallocation if significantly oversized to free memory
@ -497,9 +497,9 @@ func (b *BaseMiner) ReduceHashrateHistory(now time.Time) {
}
minuteGroups := make(map[time.Time][]int)
for _, p := range pointsToAggregate {
minute := p.Timestamp.Truncate(LowResolutionInterval)
minuteGroups[minute] = append(minuteGroups[minute], p.Hashrate)
for _, point := range pointsToAggregate {
minute := point.Timestamp.Truncate(LowResolutionInterval)
minuteGroups[minute] = append(minuteGroups[minute], point.Hashrate)
}
var newLowResPoints []HashratePoint
@ -522,8 +522,8 @@ func (b *BaseMiner) ReduceHashrateHistory(now time.Time) {
lowResCutoff := now.Add(-LowResHistoryRetention)
firstValidLowResIndex := 0
for i, p := range b.LowResHashrateHistory {
if p.Timestamp.After(lowResCutoff) || p.Timestamp.Equal(lowResCutoff) {
for i, point := range b.LowResHashrateHistory {
if point.Timestamp.After(lowResCutoff) || point.Timestamp.Equal(lowResCutoff) {
firstValidLowResIndex = i
break
}
@ -546,39 +546,39 @@ func (b *BaseMiner) ReduceHashrateHistory(now time.Time) {
// b.unzip(tmpfile.Name(), "/home/user/.local/share/lethean-desktop/miners/xmrig")
func (b *BaseMiner) unzip(src, dest string) error {
r, err := zip.OpenReader(src)
zipReader, err := zip.OpenReader(src)
if err != nil {
return err
}
defer r.Close()
defer zipReader.Close()
for _, f := range r.File {
fpath := filepath.Join(dest, f.Name)
if !strings.HasPrefix(fpath, filepath.Clean(dest)+string(os.PathSeparator)) {
return ErrInternal("illegal file path in archive").WithDetails(fpath)
for _, zipEntry := range zipReader.File {
entryPath := filepath.Join(dest, zipEntry.Name)
if !strings.HasPrefix(entryPath, filepath.Clean(dest)+string(os.PathSeparator)) {
return ErrInternal("illegal file path in archive").WithDetails(entryPath)
}
if f.FileInfo().IsDir() {
if err := os.MkdirAll(fpath, os.ModePerm); err != nil {
return ErrInternal("failed to create directory").WithCause(err).WithDetails(fpath)
if zipEntry.FileInfo().IsDir() {
if err := os.MkdirAll(entryPath, os.ModePerm); err != nil {
return ErrInternal("failed to create directory").WithCause(err).WithDetails(entryPath)
}
continue
}
if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
if err = os.MkdirAll(filepath.Dir(entryPath), os.ModePerm); err != nil {
return err
}
outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
outFile, err := os.OpenFile(entryPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, zipEntry.Mode())
if err != nil {
return err
}
rc, err := f.Open()
entryReader, err := zipEntry.Open()
if err != nil {
outFile.Close()
return err
}
_, err = io.Copy(outFile, rc)
_, err = io.Copy(outFile, entryReader)
outFile.Close()
rc.Close()
entryReader.Close()
if err != nil {
return err
}
@ -594,13 +594,13 @@ func (b *BaseMiner) untar(src, dest string) error {
}
defer file.Close()
gzr, err := gzip.NewReader(file)
gzipReader, err := gzip.NewReader(file)
if err != nil {
return err
}
defer gzr.Close()
defer gzipReader.Close()
tarReader := tar.NewReader(gzr)
tarReader := tar.NewReader(gzipReader)
for {
header, err := tarReader.Next()
@ -625,15 +625,15 @@ func (b *BaseMiner) untar(src, dest string) error {
if err := os.MkdirAll(filepath.Dir(target), 0755); err != nil {
return err
}
f, err := os.OpenFile(target, os.O_CREATE|os.O_RDWR|os.O_TRUNC, os.FileMode(header.Mode))
outputFile, err := os.OpenFile(target, os.O_CREATE|os.O_RDWR|os.O_TRUNC, os.FileMode(header.Mode))
if err != nil {
return err
}
if _, err := io.Copy(f, tarReader); err != nil {
f.Close()
if _, err := io.Copy(outputFile, tarReader); err != nil {
outputFile.Close()
return err
}
f.Close()
outputFile.Close()
}
}
}

4
pkg/mining/simulated_miner.go
View file

@ -374,8 +374,8 @@ func (m *SimulatedMiner) ReduceHashrateHistory(now time.Time) {
// Average the old points and add to low-res
if len(toMove) > 0 {
var sum int
for _, p := range toMove {
sum += p.Hashrate
for _, point := range toMove {
sum += point.Hashrate
}
avg := sum / len(toMove)
m.LowResHistory = append(m.LowResHistory, HashratePoint{

4
pkg/mining/ttminer_start.go
View file

@ -227,8 +227,8 @@ func isValidArgValue(arg string) bool {
";", "|", "&", "`", "$", "(", ")", "{", "}",
"<", ">", "\n", "\r", "\\", "'", "\"", "!",
}
for _, p := range dangerousPatterns {
if strings.Contains(arg, p) {
for _, pattern := range dangerousPatterns {
if strings.Contains(arg, pattern) {
return false
}
}