Merge pull request #1755 from AkihiroSuda/fix-errors-join

AkihiroSuda · web-flow · commit da1260dc87fb · 2023-08-19T20:33:14.000+09:00
Fix usage of `errors.Join`
diff --git a/pkg/hostagent/hostagent.go b/pkg/hostagent/hostagent.go
@@ -399,9 +399,9 @@ func (a *HostAgent) startHostAgentRoutines(ctx context.Context) error {
 		}
 		return nil
 	})
-	var mErr error
+	var errs []error
 	if err := a.waitForRequirements("essential", a.essentialRequirements()); err != nil {
-		mErr = errors.Join(mErr, err)
+		errs = append(errs, err)
 	}
 	if *a.y.SSH.ForwardAgent {
 		faScript := `#!/bin/bash
@@ -413,79 +413,79 @@ sudo chown -R "${USER}" /run/host-services`
 		stdout, stderr, err := ssh.ExecuteScript("127.0.0.1", a.sshLocalPort, a.sshConfig, faScript, faDesc)
 		logrus.Debugf("stdout=%q, stderr=%q, err=%v", stdout, stderr, err)
 		if err != nil {
-			mErr = errors.Join(mErr, fmt.Errorf("stdout=%q, stderr=%q: %w", stdout, stderr, err))
+			errs = append(errs, fmt.Errorf("stdout=%q, stderr=%q: %w", stdout, stderr, err))
 		}
 	}
 	if *a.y.MountType == limayaml.REVSSHFS {
 		mounts, err := a.setupMounts()
 		if err != nil {
-			mErr = errors.Join(mErr, err)
+			errs = append(errs, err)
 		}
 		a.onClose = append(a.onClose, func() error {
-			var unmountMErr error
+			var unmountErrs []error
 			for _, m := range mounts {
 				if unmountErr := m.close(); unmountErr != nil {
-					unmountMErr = errors.Join(unmountMErr, unmountErr)
+					unmountErrs = append(unmountErrs, unmountErr)
 				}
 			}
-			return unmountMErr
+			return errors.Join(unmountErrs...)
 		})
 	}
 	if len(a.y.AdditionalDisks) > 0 {
 		a.onClose = append(a.onClose, func() error {
-			var unlockMErr error
+			var unlockErrs []error
 			for _, d := range a.y.AdditionalDisks {
 				disk, inspectErr := store.InspectDisk(d.Name)
 				if inspectErr != nil {
-					unlockMErr = errors.Join(unlockMErr, inspectErr)
+					unlockErrs = append(unlockErrs, inspectErr)
 					continue
 				}
 				logrus.Infof("Unmounting disk %q", disk.Name)
 				if unlockErr := disk.Unlock(); unlockErr != nil {
-					unlockMErr = errors.Join(unlockMErr, unlockErr)
+					unlockErrs = append(unlockErrs, unlockErr)
 				}
 			}
-			return unlockMErr
+			return errors.Join(unlockErrs...)
 		})
 	}
 	go a.watchGuestAgentEvents(ctx)
 	if err := a.waitForRequirements("optional", a.optionalRequirements()); err != nil {
-		mErr = errors.Join(mErr, err)
+		errs = append(errs, err)
 	}
 	if err := a.waitForRequirements("final", a.finalRequirements()); err != nil {
-		mErr = errors.Join(mErr, err)
+		errs = append(errs, err)
 	}
 	// Copy all config files _after_ the requirements are done
 	for _, rule := range a.y.CopyToHost {
 		if err := copyToHost(ctx, a.sshConfig, a.sshLocalPort, rule.HostFile, rule.GuestFile); err != nil {
-			mErr = errors.Join(mErr, err)
+			errs = append(errs, err)
 		}
 	}
 	a.onClose = append(a.onClose, func() error {
-		var mErr error
+		var rmErrs []error
 		for _, rule := range a.y.CopyToHost {
 			if rule.DeleteOnStop {
 				logrus.Infof("Deleting %s", rule.HostFile)
 				if err := os.RemoveAll(rule.HostFile); err != nil {
-					mErr = errors.Join(mErr, err)
+					rmErrs = append(rmErrs, err)
 				}
 			}
 		}
-		return mErr
+		return errors.Join(rmErrs...)
 	})
-	return mErr
+	return errors.Join(errs...)
 }
 
 func (a *HostAgent) close() error {
 	logrus.Infof("Shutting down the host agent")
-	var mErr error
+	var errs []error
 	for i := len(a.onClose) - 1; i >= 0; i-- {
 		f := a.onClose[i]
 		if err := f(); err != nil {
-			mErr = errors.Join(mErr, err)
+			errs = append(errs, err)
 		}
 	}
-	return mErr
+	return errors.Join(errs...)
 }
 
 func (a *HostAgent) watchGuestAgentEvents(ctx context.Context) {
@@ -505,20 +505,20 @@ func (a *HostAgent) watchGuestAgentEvents(ctx context.Context) {
 
 	a.onClose = append(a.onClose, func() error {
 		logrus.Debugf("Stop forwarding unix sockets")
-		var mErr error
+		var errs []error
 		for _, rule := range a.y.PortForwards {
 			if rule.GuestSocket != "" {
 				local := hostAddress(rule, guestagentapi.IPPort{})
 				// using ctx.Background() because ctx has already been cancelled
 				if err := forwardSSH(context.Background(), a.sshConfig, a.sshLocalPort, local, rule.GuestSocket, verbCancel, rule.Reverse); err != nil {
-					mErr = errors.Join(mErr, err)
+					errs = append(errs, err)
 				}
 			}
 		}
 		if err := forwardSSH(context.Background(), a.sshConfig, a.sshLocalPort, localUnix, remoteUnix, verbCancel, false); err != nil {
-			mErr = errors.Join(mErr, err)
+			errs = append(errs, err)
 		}
-		return mErr
+		return errors.Join(errs...)
 	})
 
 	for {
diff --git a/pkg/hostagent/mount.go b/pkg/hostagent/mount.go
@@ -18,17 +18,17 @@ type mount struct {
 func (a *HostAgent) setupMounts() ([]*mount, error) {
 	var (
 		res  []*mount
-		mErr error
+		errs []error
 	)
 	for _, f := range a.y.Mounts {
 		m, err := a.setupMount(f)
 		if err != nil {
-			mErr = errors.Join(mErr, err)
+			errs = append(errs, err)
 			continue
 		}
 		res = append(res, m)
 	}
-	return res, mErr
+	return res, errors.Join(errs...)
 }
 
 func (a *HostAgent) setupMount(m limayaml.Mount) (*mount, error) {
diff --git a/pkg/hostagent/requirements.go b/pkg/hostagent/requirements.go
@@ -15,7 +15,7 @@ func (a *HostAgent) waitForRequirements(label string, requirements []requirement
 		retries       = 60
 		sleepDuration = 10 * time.Second
 	)
-	var mErr error
+	var errs []error
 
 	for i, req := range requirements {
 	retryLoop:
@@ -28,16 +28,17 @@ func (a *HostAgent) waitForRequirements(label string, requirements []requirement
 			}
 			if req.fatal {
 				logrus.Infof("No further %s requirements will be checked", label)
-				return errors.Join(mErr, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s; skipping further checks: %w", label, i+1, len(requirements), req.description, req.debugHint, err))
+				errs = append(errs, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s; skipping further checks: %w", label, i+1, len(requirements), req.description, req.debugHint, err))
+				return errors.Join(errs...)
 			}
 			if j == retries-1 {
-				mErr = errors.Join(mErr, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s: %w", label, i+1, len(requirements), req.description, req.debugHint, err))
+				errs = append(errs, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s: %w", label, i+1, len(requirements), req.description, req.debugHint, err))
 				break retryLoop
 			}
 			time.Sleep(10 * time.Second)
 		}
 	}
-	return mErr
+	return errors.Join(errs...)
 }
 
 func (a *HostAgent) waitForRequirement(r requirement) error {
diff --git a/pkg/qemu/qemu_driver.go b/pkg/qemu/qemu_driver.go
@@ -282,14 +282,14 @@ func (l *LimaQemuDriver) removeVNCFiles() error {
 }
 
 func (l *LimaQemuDriver) killVhosts() error {
-	var mErr error
+	var errs []error
 	for i, vhost := range l.vhostCmds {
 		if err := vhost.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) {
-			mErr = errors.Join(mErr, fmt.Errorf("Failed to kill virtiofsd instance #%d: %w", i, err))
+			errs = append(errs, fmt.Errorf("Failed to kill virtiofsd instance #%d: %w", i, err))
 		}
 	}
 
-	return mErr
+	return errors.Join(errs...)
 }
 
 func (l *LimaQemuDriver) shutdownQEMU(ctx context.Context, timeout time.Duration, qCmd *exec.Cmd, qWaitCh <-chan error) error {

Original file line number	Diff line number	Diff line change
`@@ -399,9 +399,9 @@ func (a *HostAgent) startHostAgentRoutines(ctx context.Context) error {`
`399`	`399`	`}`
`400`	`400`	`return nil`
`401`	`401`	`})`
`402`		`- var mErr error`
	`402`	`+ var errs []error`
`403`	`403`	`if err := a.waitForRequirements("essential", a.essentialRequirements()); err != nil {`
`404`		`- mErr = errors.Join(mErr, err)`
	`404`	`+ errs = append(errs, err)`
`405`	`405`	`}`
`406`	`406`	`if *a.y.SSH.ForwardAgent {`
`407`	`407`	faScript := `#!/bin/bash
@@ -413,79 +413,79 @@ sudo chown -R "${USER}" /run/host-services`
`413`	`413`	`stdout, stderr, err := ssh.ExecuteScript("127.0.0.1", a.sshLocalPort, a.sshConfig, faScript, faDesc)`
`414`	`414`	`logrus.Debugf("stdout=%q, stderr=%q, err=%v", stdout, stderr, err)`
`415`	`415`	`if err != nil {`
`416`		`- mErr = errors.Join(mErr, fmt.Errorf("stdout=%q, stderr=%q: %w", stdout, stderr, err))`
	`416`	`+ errs = append(errs, fmt.Errorf("stdout=%q, stderr=%q: %w", stdout, stderr, err))`
`417`	`417`	`}`
`418`	`418`	`}`
`419`	`419`	`if *a.y.MountType == limayaml.REVSSHFS {`
`420`	`420`	`mounts, err := a.setupMounts()`
`421`	`421`	`if err != nil {`
`422`		`- mErr = errors.Join(mErr, err)`
	`422`	`+ errs = append(errs, err)`
`423`	`423`	`}`
`424`	`424`	`a.onClose = append(a.onClose, func() error {`
`425`		`- var unmountMErr error`
	`425`	`+ var unmountErrs []error`
`426`	`426`	`for _, m := range mounts {`
`427`	`427`	`if unmountErr := m.close(); unmountErr != nil {`
`428`		`- unmountMErr = errors.Join(unmountMErr, unmountErr)`
	`428`	`+ unmountErrs = append(unmountErrs, unmountErr)`
`429`	`429`	`}`
`430`	`430`	`}`
`431`		`- return unmountMErr`
	`431`	`+ return errors.Join(unmountErrs...)`
`432`	`432`	`})`
`433`	`433`	`}`
`434`	`434`	`if len(a.y.AdditionalDisks) > 0 {`
`435`	`435`	`a.onClose = append(a.onClose, func() error {`
`436`		`- var unlockMErr error`
	`436`	`+ var unlockErrs []error`
`437`	`437`	`for _, d := range a.y.AdditionalDisks {`
`438`	`438`	`disk, inspectErr := store.InspectDisk(d.Name)`
`439`	`439`	`if inspectErr != nil {`
`440`		`- unlockMErr = errors.Join(unlockMErr, inspectErr)`
	`440`	`+ unlockErrs = append(unlockErrs, inspectErr)`
`441`	`441`	`continue`
`442`	`442`	`}`
`443`	`443`	`logrus.Infof("Unmounting disk %q", disk.Name)`
`444`	`444`	`if unlockErr := disk.Unlock(); unlockErr != nil {`
`445`		`- unlockMErr = errors.Join(unlockMErr, unlockErr)`
	`445`	`+ unlockErrs = append(unlockErrs, unlockErr)`
`446`	`446`	`}`
`447`	`447`	`}`
`448`		`- return unlockMErr`
	`448`	`+ return errors.Join(unlockErrs...)`
`449`	`449`	`})`
`450`	`450`	`}`
`451`	`451`	`go a.watchGuestAgentEvents(ctx)`
`452`	`452`	`if err := a.waitForRequirements("optional", a.optionalRequirements()); err != nil {`
`453`		`- mErr = errors.Join(mErr, err)`
	`453`	`+ errs = append(errs, err)`
`454`	`454`	`}`
`455`	`455`	`if err := a.waitForRequirements("final", a.finalRequirements()); err != nil {`
`456`		`- mErr = errors.Join(mErr, err)`
	`456`	`+ errs = append(errs, err)`
`457`	`457`	`}`
`458`	`458`	`// Copy all config files _after_ the requirements are done`
`459`	`459`	`for _, rule := range a.y.CopyToHost {`
`460`	`460`	`if err := copyToHost(ctx, a.sshConfig, a.sshLocalPort, rule.HostFile, rule.GuestFile); err != nil {`
`461`		`- mErr = errors.Join(mErr, err)`
	`461`	`+ errs = append(errs, err)`
`462`	`462`	`}`
`463`	`463`	`}`
`464`	`464`	`a.onClose = append(a.onClose, func() error {`
`465`		`- var mErr error`
	`465`	`+ var rmErrs []error`
`466`	`466`	`for _, rule := range a.y.CopyToHost {`
`467`	`467`	`if rule.DeleteOnStop {`
`468`	`468`	`logrus.Infof("Deleting %s", rule.HostFile)`
`469`	`469`	`if err := os.RemoveAll(rule.HostFile); err != nil {`
`470`		`- mErr = errors.Join(mErr, err)`
	`470`	`+ rmErrs = append(rmErrs, err)`
`471`	`471`	`}`
`472`	`472`	`}`
`473`	`473`	`}`
`474`		`- return mErr`
	`474`	`+ return errors.Join(rmErrs...)`
`475`	`475`	`})`
`476`		`- return mErr`
	`476`	`+ return errors.Join(errs...)`
`477`	`477`	`}`
`478`	`478`
`479`	`479`	`func (a *HostAgent) close() error {`
`480`	`480`	`logrus.Infof("Shutting down the host agent")`
`481`		`- var mErr error`
	`481`	`+ var errs []error`
`482`	`482`	`for i := len(a.onClose) - 1; i >= 0; i-- {`
`483`	`483`	`f := a.onClose[i]`
`484`	`484`	`if err := f(); err != nil {`
`485`		`- mErr = errors.Join(mErr, err)`
	`485`	`+ errs = append(errs, err)`
`486`	`486`	`}`
`487`	`487`	`}`
`488`		`- return mErr`
	`488`	`+ return errors.Join(errs...)`
`489`	`489`	`}`
`490`	`490`
`491`	`491`	`func (a *HostAgent) watchGuestAgentEvents(ctx context.Context) {`
`@@ -505,20 +505,20 @@ func (a *HostAgent) watchGuestAgentEvents(ctx context.Context) {`
`505`	`505`
`506`	`506`	`a.onClose = append(a.onClose, func() error {`
`507`	`507`	`logrus.Debugf("Stop forwarding unix sockets")`
`508`		`- var mErr error`
	`508`	`+ var errs []error`
`509`	`509`	`for _, rule := range a.y.PortForwards {`
`510`	`510`	`if rule.GuestSocket != "" {`
`511`	`511`	`local := hostAddress(rule, guestagentapi.IPPort{})`
`512`	`512`	`// using ctx.Background() because ctx has already been cancelled`
`513`	`513`	`if err := forwardSSH(context.Background(), a.sshConfig, a.sshLocalPort, local, rule.GuestSocket, verbCancel, rule.Reverse); err != nil {`
`514`		`- mErr = errors.Join(mErr, err)`
	`514`	`+ errs = append(errs, err)`
`515`	`515`	`}`
`516`	`516`	`}`
`517`	`517`	`}`
`518`	`518`	`if err := forwardSSH(context.Background(), a.sshConfig, a.sshLocalPort, localUnix, remoteUnix, verbCancel, false); err != nil {`
`519`		`- mErr = errors.Join(mErr, err)`
	`519`	`+ errs = append(errs, err)`
`520`	`520`	`}`
`521`		`- return mErr`
	`521`	`+ return errors.Join(errs...)`
`522`	`522`	`})`
`523`	`523`
`524`	`524`	`for {`
Original file line number	Diff line number	Diff line change
`@@ -18,17 +18,17 @@ type mount struct {`
`18`	`18`	`func (a HostAgent) setupMounts() ([]mount, error) {`
`19`	`19`	`var (`
`20`	`20`	`res []*mount`
`21`		`- mErr error`
	`21`	`+ errs []error`
`22`	`22`	`)`
`23`	`23`	`for _, f := range a.y.Mounts {`
`24`	`24`	`m, err := a.setupMount(f)`
`25`	`25`	`if err != nil {`
`26`		`- mErr = errors.Join(mErr, err)`
	`26`	`+ errs = append(errs, err)`
`27`	`27`	`continue`
`28`	`28`	`}`
`29`	`29`	`res = append(res, m)`
`30`	`30`	`}`
`31`		`- return res, mErr`
	`31`	`+ return res, errors.Join(errs...)`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`func (a HostAgent) setupMount(m limayaml.Mount) (mount, error) {`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ func (a *HostAgent) waitForRequirements(label string, requirements []requirement`
`15`	`15`	`retries = 60`
`16`	`16`	`sleepDuration = 10 * time.Second`
`17`	`17`	`)`
`18`		`- var mErr error`
	`18`	`+ var errs []error`
`19`	`19`
`20`	`20`	`for i, req := range requirements {`
`21`	`21`	`retryLoop:`
`@@ -28,16 +28,17 @@ func (a *HostAgent) waitForRequirements(label string, requirements []requirement`
`28`	`28`	`}`
`29`	`29`	`if req.fatal {`
`30`	`30`	`logrus.Infof("No further %s requirements will be checked", label)`
`31`		`- return errors.Join(mErr, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s; skipping further checks: %w", label, i+1, len(requirements), req.description, req.debugHint, err))`
	`31`	`+ errs = append(errs, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s; skipping further checks: %w", label, i+1, len(requirements), req.description, req.debugHint, err))`
	`32`	`+ return errors.Join(errs...)`
`32`	`33`	`}`
`33`	`34`	`if j == retries-1 {`
`34`		`- mErr = errors.Join(mErr, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s: %w", label, i+1, len(requirements), req.description, req.debugHint, err))`
	`35`	`+ errs = append(errs, fmt.Errorf("failed to satisfy the %s requirement %d of %d %q: %s: %w", label, i+1, len(requirements), req.description, req.debugHint, err))`
`35`	`36`	`break retryLoop`
`36`	`37`	`}`
`37`	`38`	`time.Sleep(10 * time.Second)`
`38`	`39`	`}`
`39`	`40`	`}`
`40`		`- return mErr`
	`41`	`+ return errors.Join(errs...)`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`func (a *HostAgent) waitForRequirement(r requirement) error {`
Original file line number	Diff line number	Diff line change
`@@ -282,14 +282,14 @@ func (l *LimaQemuDriver) removeVNCFiles() error {`
`282`	`282`	`}`
`283`	`283`
`284`	`284`	`func (l *LimaQemuDriver) killVhosts() error {`
`285`		`- var mErr error`
	`285`	`+ var errs []error`
`286`	`286`	`for i, vhost := range l.vhostCmds {`
`287`	`287`	`if err := vhost.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) {`
`288`		`- mErr = errors.Join(mErr, fmt.Errorf("Failed to kill virtiofsd instance #%d: %w", i, err))`
	`288`	`+ errs = append(errs, fmt.Errorf("Failed to kill virtiofsd instance #%d: %w", i, err))`
`289`	`289`	`}`
`290`	`290`	`}`
`291`	`291`
`292`		`- return mErr`
	`292`	`+ return errors.Join(errs...)`
`293`	`293`	`}`
`294`	`294`
`295`	`295`	`func (l LimaQemuDriver) shutdownQEMU(ctx context.Context, timeout time.Duration, qCmd exec.Cmd, qWaitCh <-chan error) error {`