aws/aws-k8s-tester: ec2/logs.go; 243 LoC

Found a possible issue in [aws/aws-k8s-tester](https://www.github.com/aws/aws-k8s-tester) at [ec2/logs.go](https://github.com/aws/aws-k8s-tester/blob/9de34464ab1bd0978f300a6156dc3aa7033355c2/ec2/logs.go#L138-L380)

Below is the message reported by the analyzer for this snippet of code. Beware that the analyzer only reports the first issue it finds, so please do not limit your consideration to the contents of the below message.

> range-loop variable name used in defer or goroutine at line 178

[Click here to see the code in its original context.](https://github.com/aws/aws-k8s-tester/blob/9de34464ab1bd0978f300a6156dc3aa7033355c2/ec2/logs.go#L138-L380)

Click here to show the 243 line(s) of Go which triggered the analyzer.

```go
for name, cur := range ts.cfg.ASGs {
ts.lg.Info("fetching logs",
zap.String("asg-name", name),
zap.Int("instances", len(cur.Instances)),
)
waits += len(cur.Instances)

for instID, iv := range cur.Instances {
pfx := instID + "-"

go func(instID, logsDir, pfx string, iv ec2config.Instance) {
select {
case <-ts.stopCreationCh:
ts.lg.Warn("exiting fetch logger", zap.String("prefix", pfx))
return
default:
}

if !rateLimiter.Allow() {
ts.lg.Debug("waiting for rate limiter before SSH into the machine",
zap.Float32("qps", qps),
zap.Int("burst", burst),
zap.String("instance-id", instID),
)
werr := rateLimiter.Wait(context.Background())
ts.lg.Debug("waited for rate limiter",
zap.Float32("qps", qps),
zap.Int("burst", burst),
zap.Error(werr),
)
}

sh, err := ssh.New(ssh.Config{
Logger: ts.lg,
KeyPath: ts.cfg.RemoteAccessPrivateKeyPath,
PublicIP: iv.PublicIP,
PublicDNSName: iv.PublicDNSName,
UserName: iv.RemoteAccessUserName,
})
if err != nil {
rch <- instanceLogs{asgName: name, errs: []string{err.Error()}}
return
}
defer sh.Close()
if err = sh.Connect(); err != nil {
rch <- instanceLogs{asgName: name, errs: []string{err.Error()}}
return
}

data := instanceLogs{asgName: name, instanceID: instID}
// fetch default logs
for cmd, fileName := range commandToFileName {
if !rateLimiter.Allow() {
ts.lg.Debug("waiting for rate limiter before fetching file")
werr := rateLimiter.Wait(context.Background())
ts.lg.Debug("waited for rate limiter", zap.Error(werr))
}
out, oerr := sh.Run(cmd, sshOpt)
if oerr != nil {
data.errs = append(data.errs, fmt.Sprintf("failed to run command %q for %q (error %v)", cmd, instID, oerr))
continue
}

fpath := filepath.Join(logsDir, shorten(ts.lg, pfx+fileName))
f, err := os.Create(fpath)
if err != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to create a file %q for %q (error %v)",
fpath,
instID,
err,
))
continue
}
if _, err = f.Write(out); err != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to write to a file %q for %q (error %v)",
fpath,
instID,
err,
))
f.Close()
continue
}
f.Close()
ts.lg.Debug("wrote", zap.String("file-path", fpath))
data.paths = append(data.paths, fpath)
}

if !rateLimiter.Allow() {
ts.lg.Debug("waiting for rate limiter before fetching file")
werr := rateLimiter.Wait(context.Background())
ts.lg.Debug("waited for rate limiter", zap.Error(werr))
}
ts.lg.Info("listing systemd service units", zap.String("instance-id", instID))
listCmd := "sudo systemctl list-units -t service --no-pager --no-legend --all"
out, oerr := sh.Run(listCmd, sshOpt)
if oerr != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to run command %q for %q (error %v)",
listCmd,
instID,
oerr,
))
} else {
/*
auditd.service loaded active running Security Auditing Service
auth-rpcgss-module.service loaded inactive dead Kernel Module supporting RPCSEC_GSS
*/
svcCmdToFileName := make(map[string]string)
for _, line := range strings.Split(string(out), "\n") {
fields := strings.Fields(line)
if len(fields) == 0 || fields[0] == "" || len(fields) < 5 {
continue
}
if fields[1] == "not-found" {
continue
}
if fields[2] == "inactive" {
continue
}
svc := fields[0]
svcCmd := "sudo journalctl --no-pager --output=cat -u " + svc
svcFileName := svc + ".out.log"
svcCmdToFileName[svcCmd] = svcFileName
}
for cmd, fileName := range svcCmdToFileName {
if !rateLimiter.Allow() {
ts.lg.Debug("waiting for rate limiter before fetching file")
werr := rateLimiter.Wait(context.Background())
ts.lg.Debug("waited for rate limiter", zap.Error(werr))
}
out, oerr := sh.Run(cmd, sshOpt)
if oerr != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to run command %q for %q (error %v)",
listCmd,
instID,
oerr,
))
continue
}

fpath := filepath.Join(logsDir, shorten(ts.lg, pfx+fileName))
f, err := os.Create(fpath)
if err != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to create a file %q for %q (error %v)",
fpath,
instID,
err,
))
continue
}
if _, err = f.Write(out); err != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to write to a file %q for %q (error %v)",
fpath,
instID,
err,
))
f.Close()
continue
}
f.Close()
ts.lg.Debug("wrote", zap.String("file-path", fpath))
data.paths = append(data.paths, fpath)
}
}

if !rateLimiter.Allow() {
ts.lg.Debug("waiting for rate limiter before fetching file")
werr := rateLimiter.Wait(context.Background())
ts.lg.Debug("waited for rate limiter", zap.Error(werr))
}
ts.lg.Info("listing /var/log", zap.String("instance-id", instID))
findCmd := "sudo find /var/log ! -type d"
out, oerr = sh.Run(findCmd, sshOpt)
if oerr != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to run command %q for %q (error %v)",
findCmd,
instID,
oerr,
))
} else {
varLogCmdToFileName := make(map[string]string)
for _, line := range strings.Split(string(out), "\n") {
if len(line) == 0 {
// last value
continue
}
logCmd := "sudo cat " + line
logName := filepath.Base(line)
varLogCmdToFileName[logCmd] = logName
}
for cmd, fileName := range varLogCmdToFileName {
if !rateLimiter.Allow() {
ts.lg.Debug("waiting for rate limiter before fetching file")
werr := rateLimiter.Wait(context.Background())
ts.lg.Debug("waited for rate limiter", zap.Error(werr))
}
out, oerr := sh.Run(cmd, sshOpt)
if oerr != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to run command %q for %q (error %v)",
cmd,
instID,
oerr,
))
continue
}

fpath := filepath.Join(logsDir, shorten(ts.lg, pfx+fileName))
f, err := os.Create(fpath)
if err != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to create a file %q for %q (error %v)",
fpath,
instID,
err,
))
continue
}
if _, err = f.Write(out); err != nil {
data.errs = append(data.errs, fmt.Sprintf(
"failed to write to a file %q for %q (error %v)",
fpath,
instID,
err,
))
f.Close()
continue
}
f.Close()
ts.lg.Debug("wrote", zap.String("file-path", fpath))
data.paths = append(data.paths, fpath)
}
}
rch <- data
}(instID, logsDir, pfx, iv)
}
}

```

Leave a reaction on this issue to contribute to the project by classifying this instance as a **Bug** :-1:, **Mitigated** :+1:, or **Desirable Behavior** :rocket:
See the descriptions of the classifications [here](https://github.com/github-vet/rangeclosure-findings#how-can-i-help) for more information.

commit ID: 9de34464ab1bd0978f300a6156dc3aa7033355c2