diff --git a/cmd/minikube/cmd/completion.go b/cmd/minikube/cmd/completion.go index b85d4e9a59..09070538fe 100644 --- a/cmd/minikube/cmd/completion.go +++ b/cmd/minikube/cmd/completion.go @@ -18,10 +18,10 @@ package cmd import ( "bytes" + "fmt" "io" "os" - "github.com/pkg/errors" "github.com/spf13/cobra" "k8s.io/minikube/pkg/minikube/exit" "k8s.io/minikube/pkg/minikube/out" @@ -155,7 +155,7 @@ func GenerateBashCompletion(w io.Writer, cmd *cobra.Command) error { err = cmd.GenBashCompletion(w) if err != nil { - return errors.Wrap(err, "Error generating bash completion") + return fmt.Errorf("Error generating bash completion: %w", err) } return nil @@ -318,7 +318,7 @@ __minikube_convert_bash_to_zsh() { buf := new(bytes.Buffer) err = cmd.GenBashCompletion(buf) if err != nil { - return errors.Wrap(err, "Error generating zsh completion") + return fmt.Errorf("Error generating zsh completion: %w", err) } _, err = w.Write(buf.Bytes()) if err != nil { @@ -347,7 +347,7 @@ func GenerateFishCompletion(w io.Writer, cmd *cobra.Command) error { err = cmd.GenFishCompletion(w, true) if err != nil { - return errors.Wrap(err, "Error generating fish completion") + return fmt.Errorf("Error generating fish completion: %w", err) } return nil @@ -362,7 +362,7 @@ func GeneratePowerShellCompletion(w io.Writer, cmd *cobra.Command) error { err = cmd.GenPowerShellCompletionWithDesc(w) if err != nil { - return errors.Wrap(err, "Error generating powershell completion") + return fmt.Errorf("Error generating powershell completion: %w", err) } return nil diff --git a/cmd/minikube/cmd/config/set.go b/cmd/minikube/cmd/config/set.go index 41ae18c9e7..0536e7abeb 100644 --- a/cmd/minikube/cmd/config/set.go +++ b/cmd/minikube/cmd/config/set.go @@ -17,7 +17,8 @@ limitations under the License. package config import ( - "github.com/pkg/errors" + "fmt" + "github.com/spf13/cobra" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/exit" @@ -53,28 +54,28 @@ func init() { func Set(name string, value string) error { s, err := findSetting(name) if err != nil { - return errors.Wrapf(err, "find settings for %q value of %q", name, value) + return fmt.Errorf("find settings for %q value of %q: %w", name, value, err) } // Validate the new value err = invoke(name, value, s.validations) if err != nil { - return errors.Wrapf(err, "run validations for %q with value of %q", name, value) + return fmt.Errorf("run validations for %q with value of %q: %w", name, value, err) } // Set the value cc, err := config.ReadConfig(localpath.ConfigFile()) if err != nil { - return errors.Wrapf(err, "read config file %q", localpath.ConfigFile()) + return fmt.Errorf("read config file %q: %w", localpath.ConfigFile(), err) } err = s.set(cc, name, value) if err != nil { - return errors.Wrapf(err, "set") + return fmt.Errorf("set: %w", err) } // Run any callbacks for this property err = invoke(name, value, s.callbacks) if err != nil { - return errors.Wrapf(err, "run callbacks for %q with value of %q", name, value) + return fmt.Errorf("run callbacks for %q with value of %q: %w", name, value, err) } // Write the value diff --git a/cmd/minikube/cmd/cp.go b/cmd/minikube/cmd/cp.go index ca0cf70033..3d00afee59 100644 --- a/cmd/minikube/cmd/cp.go +++ b/cmd/minikube/cmd/cp.go @@ -19,7 +19,6 @@ package cmd import ( "path/filepath" - "github.com/pkg/errors" "github.com/spf13/cobra" "fmt" @@ -153,13 +152,13 @@ func remoteCommandRunner(co *mustload.ClusterController, nodeName string) comman h, err := machine.GetHost(co.API, *co.Config, *n) if err != nil { - out.ErrLn("%v", errors.Wrap(err, "getting host")) + out.ErrLn("%v", fmt.Errorf("getting host: %w", err)) os.Exit(1) } runner, err := machine.CommandRunner(h) if err != nil { - out.ErrLn("%v", errors.Wrap(err, "getting command runner")) + out.ErrLn("%v", fmt.Errorf("getting command runner: %w", err)) os.Exit(1) } @@ -172,7 +171,7 @@ func copyableFile(co *mustload.ClusterController, src, dst *remotePath) assets.C runner := remoteCommandRunner(co, src.node) f, err := runner.ReadableFile(src.path) if err != nil { - out.ErrLn("%v", errors.Wrapf(err, "getting file from %s node", src.node)) + out.ErrLn("%v", fmt.Errorf("getting file from %s node: %w", src.node, err)) os.Exit(1) } @@ -193,7 +192,7 @@ func copyableFile(co *mustload.ClusterController, src, dst *remotePath) assets.C fa, err := assets.NewFileAsset(src.path, pt.Dir(dst.path), pt.Base(dst.path), "0644") if err != nil { - out.ErrLn("%v", errors.Wrap(err, "getting file asset")) + out.ErrLn("%v", fmt.Errorf("getting file asset: %w", err)) os.Exit(1) } diff --git a/cmd/minikube/cmd/dashboard.go b/cmd/minikube/cmd/dashboard.go index 5afbcca26f..7a3a9c0a5e 100644 --- a/cmd/minikube/cmd/dashboard.go +++ b/cmd/minikube/cmd/dashboard.go @@ -27,7 +27,6 @@ import ( "strconv" "time" - "github.com/pkg/errors" "github.com/spf13/cobra" "k8s.io/klog/v2" "k8s.io/minikube/cmd/minikube/cmd/flags" @@ -148,12 +147,12 @@ func kubectlProxy(kubectlVersion string, binaryURL string, contextName string, p stdoutPipe, err := cmd.StdoutPipe() if err != nil { - return nil, "", errors.Wrap(err, "cmd stdout") + return nil, "", fmt.Errorf("cmd stdout: %w", err) } klog.Infof("Executing: %s %s", cmd.Path, cmd.Args) if err := cmd.Start(); err != nil { - return nil, "", errors.Wrap(err, "proxy start") + return nil, "", fmt.Errorf("proxy start: %w", err) } klog.Infof("Waiting for kubectl to output host:port ...") @@ -214,7 +213,7 @@ func dashboardURL(addr string, ns string, svc string) string { func checkURL(url string) error { resp, err := http.Get(url) if err != nil { - return errors.Wrapf(err, "hitting URL:%q\n response: %+v", url, resp) + return fmt.Errorf("hitting URL:%q\n response: %+v: %w", url, resp, err) } if resp.StatusCode != http.StatusOK { return &retry.RetriableError{ diff --git a/cmd/minikube/cmd/delete.go b/cmd/minikube/cmd/delete.go index 6e920ec617..e463a517c4 100644 --- a/cmd/minikube/cmd/delete.go +++ b/cmd/minikube/cmd/delete.go @@ -26,7 +26,8 @@ import ( "strings" "time" - "github.com/pkg/errors" + "errors" + "github.com/shirou/gopsutil/v4/process" "k8s.io/minikube/pkg/libmachine/mcnerror" @@ -435,10 +436,10 @@ func deleteHosts(api libmachine.API, cc *config.ClusterConfig) { for _, n := range cc.Nodes { machineName := config.MachineName(*cc, n) if err := machine.DeleteHost(api, machineName); err != nil { - switch errors.Cause(err).(type) { - case mcnerror.ErrHostDoesNotExist: + var e mcnerror.ErrHostDoesNotExist + if errors.As(err, &e) { klog.Infof("Host %s does not exist. Proceeding ahead with cleanup.", machineName) - default: + } else { out.FailureT("Failed to delete cluster: {{.error}}", out.V{"error": err}) out.Styled(style.Notice, `You may need to manually remove the "{{.name}}" VM from your hypervisor`, out.V{"name": machineName}) } @@ -653,7 +654,7 @@ func killProcess(path string) error { // if no errors were encountered, it's safe to delete pidFile if err := os.Remove(pidPath); err != nil { - return errors.Wrap(err, "while closing mount-pids file") + return fmt.Errorf("while closing mount-pids file: %w", err) } return nil @@ -674,13 +675,13 @@ func trySigKillProcess(pid int) error { proc, err := os.FindProcess(pid) if err != nil { - return errors.Wrapf(err, "os.FindProcess: %d", pid) + return fmt.Errorf("os.FindProcess: %d: %w", pid, err) } klog.Infof("Killing pid %d ...", pid) if err := proc.Kill(); err != nil { klog.Infof("Kill failed with %v - removing probably stale pid...", err) - return errors.Wrapf(err, "removing likely stale unkillable pid: %d", pid) + return fmt.Errorf("removing likely stale unkillable pid: %d: %w", pid, err) } return nil @@ -717,7 +718,7 @@ var isMinikubeProcess = func(pid int) (bool, error) { func getPids(path string) ([]int, error) { data, err := os.ReadFile(path) if err != nil { - return nil, errors.Wrap(err, "ReadFile") + return nil, fmt.Errorf("ReadFile: %w", err) } klog.Infof("pidfile contents: %s", data) diff --git a/cmd/minikube/cmd/mount.go b/cmd/minikube/cmd/mount.go index a04f7fc09a..026a3b94e1 100644 --- a/cmd/minikube/cmd/mount.go +++ b/cmd/minikube/cmd/mount.go @@ -28,7 +28,6 @@ import ( "sync" "syscall" - "github.com/pkg/errors" "github.com/spf13/cobra" "k8s.io/klog/v2" "k8s.io/minikube/cmd/minikube/cmd/flags" @@ -281,7 +280,7 @@ func getPort() (int, error) { l, err := net.ListenTCP("tcp", addr) if err != nil { - return -1, errors.Errorf("Error accessing port %d", addr.Port) + return -1, fmt.Errorf("Error accessing port %d", addr.Port) } defer l.Close() return l.Addr().(*net.TCPAddr).Port, nil @@ -318,7 +317,7 @@ func removePid(path string, pid string) error { // we're reading the pids... data, err := os.ReadFile(pidPath) if err != nil { - return errors.Wrap(err, "readFile") + return fmt.Errorf("readFile: %w", err) } pids := []string{} diff --git a/cmd/minikube/cmd/start.go b/cmd/minikube/cmd/start.go index 5889d99f2a..2dd906ba7c 100644 --- a/cmd/minikube/cmd/start.go +++ b/cmd/minikube/cmd/start.go @@ -34,13 +34,14 @@ import ( "strings" "time" + "errors" + "github.com/Delta456/box-cli-maker/v2" "github.com/blang/semver/v4" "github.com/docker/go-connections/nat" "github.com/google/go-containerregistry/pkg/authn" "github.com/google/go-containerregistry/pkg/name" "github.com/google/go-containerregistry/pkg/v1/remote" - "github.com/pkg/errors" "github.com/shirou/gopsutil/v4/cpu" gopshost "github.com/shirou/gopsutil/v4/host" "github.com/spf13/cobra" @@ -348,7 +349,7 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing * rtime := getContainerRuntime(existing) cc, n, err := generateClusterConfig(cmd, existing, k8sVersion, rtime, driverName, options) if err != nil { - return node.Starter{}, errors.Wrap(err, "Failed to generate cluster config") + return node.Starter{}, fmt.Errorf("Failed to generate cluster config: %w", err) } klog.Infof("cluster config:\n%+v", cc) @@ -371,7 +372,7 @@ func provisionWithDriver(cmd *cobra.Command, ds registry.DriverState, existing * if driver.IsVM(driverName) && !driver.IsSSH(driverName) { urlString, err := download.ISO(viper.GetStringSlice(isoURL), cmd.Flags().Changed(isoURL)) if err != nil { - return node.Starter{}, errors.Wrap(err, "Failed to cache ISO") + return node.Starter{}, fmt.Errorf("Failed to cache ISO: %w", err) } cc.MinikubeISO = urlString } @@ -521,7 +522,7 @@ func startWithDriver(cmd *cobra.Command, starter node.Starter, existing *config. out.Ln("") // extra newline for clarity on the command line if err := node.Add(starter.Cfg, n, viper.GetBool(deleteOnFailure), options); err != nil { - return nil, errors.Wrap(err, "adding node") + return nil, fmt.Errorf("adding node: %w", err) } } @@ -617,7 +618,7 @@ func showKubectlInfo(kcs *kubeconfig.Settings, k8sVersion, rtime, machineName st client, err := semver.Make(strings.TrimPrefix(gitVersion, version.VersionPrefix)) if err != nil { - return errors.Wrap(err, "client semver") + return fmt.Errorf("client semver: %w", err) } cluster := semver.MustParse(strings.TrimPrefix(k8sVersion, version.VersionPrefix)) @@ -688,7 +689,7 @@ func kubectlVersion(path string) (string, error) { // really old Kubernetes clients did not have the --output parameter b, err := exec.Command(path, "version", "--client", "--short").Output() if err != nil { - return "", errors.Wrap(err, "exec") + return "", fmt.Errorf("exec: %w", err) } s := strings.TrimSpace(string(b)) return strings.Replace(s, "Client Version: ", "", 1), nil @@ -701,7 +702,7 @@ func kubectlVersion(path string) (string, error) { }{} err = json.Unmarshal(j, &cv) if err != nil { - return "", errors.Wrap(err, "unmarshal") + return "", fmt.Errorf("unmarshal: %w", err) } return cv.ClientVersion.GitVersion, nil @@ -1406,7 +1407,7 @@ func validatePorts(ports []string) error { } _, portBindingsMap, err := nat.ParsePortSpecs(portSpecs) if err != nil { - return errors.Errorf("Sorry, one of the ports provided with --ports flag is not valid %s (%v)", ports, err) + return fmt.Errorf("Sorry, one of the ports provided with --ports flag is not valid %s (%v)", ports, err) } for exposedPort, portBindings := range portBindingsMap { exposedPorts = append(exposedPorts, exposedPort.Port()) @@ -1430,10 +1431,10 @@ func validatePorts(ports []string) error { func validatePort(port string) error { p, err := strconv.Atoi(port) if err != nil { - return errors.Errorf("Sorry, one of the ports provided with --ports flag is not valid: %s", port) + return fmt.Errorf("Sorry, one of the ports provided with --ports flag is not valid: %s", port) } if p > 65535 || p < 1 { - return errors.Errorf("Sorry, one of the ports provided with --ports flag is outside range: %s", port) + return fmt.Errorf("Sorry, one of the ports provided with --ports flag is outside range: %s", port) } return nil } @@ -1442,10 +1443,10 @@ func validatePort(port string) error { func validateDiskSize(diskSize string) error { diskSizeMB, err := util.CalculateSizeInMB(diskSize) if err != nil { - return errors.Errorf("Validation unable to parse disk size %v: %v", diskSize, err) + return fmt.Errorf("Validation unable to parse disk size %v: %v", diskSize, err) } if diskSizeMB < minimumDiskSize { - return errors.Errorf("Requested disk size %v is less than minimum of %v", diskSizeMB, minimumDiskSize) + return fmt.Errorf("Requested disk size %v is less than minimum of %v", diskSizeMB, minimumDiskSize) } return nil } @@ -1474,11 +1475,11 @@ func validateRuntime(rtime string) error { } if (rtime == "crio" || rtime == "cri-o") && strings.HasPrefix(runtime.GOARCH, "ppc64") { - return errors.Errorf("The %s runtime is not compatible with the %s architecture. See https://github.com/cri-o/cri-o/issues/2467 for more details", rtime, runtime.GOARCH) + return fmt.Errorf("The %s runtime is not compatible with the %s architecture. See https://github.com/cri-o/cri-o/issues/2467 for more details", rtime, runtime.GOARCH) } if !validRuntime { - return errors.Errorf("Invalid Container Runtime: %s. Valid runtimes are: %s", rtime, cruntime.ValidRuntimes()) + return fmt.Errorf("Invalid Container Runtime: %s. Valid runtimes are: %s", rtime, cruntime.ValidRuntimes()) } return nil } @@ -1492,12 +1493,12 @@ func validateGPUs(value, drvName, rtime string) error { return err } if value != "nvidia" && value != "all" && value != "amd" && value != "nvidia.com" { - return errors.Errorf(`The gpus flag must be passed a value of "nvidia", "nvidia.com", "amd" or "all"`) + return fmt.Errorf(`The gpus flag must be passed a value of "nvidia", "nvidia.com", "amd" or "all"`) } if drvName == constants.Docker && (rtime == constants.Docker || rtime == constants.DefaultContainerRuntime) { return nil } - return errors.Errorf("The gpus flag can only be used with the docker driver and docker container-runtime") + return fmt.Errorf("The gpus flag can only be used with the docker driver and docker container-runtime") } func validateGPUsArch() error { @@ -1505,7 +1506,7 @@ func validateGPUsArch() error { case "amd64", "arm64", "ppc64le": return nil } - return errors.Errorf("The GPUs flag is only supported on amd64, arm64 & ppc64le, currently using %s", runtime.GOARCH) + return fmt.Errorf("The GPUs flag is only supported on amd64, arm64 & ppc64le, currently using %s", runtime.GOARCH) } func validateAutoPauseInterval(interval time.Duration) error { @@ -1710,7 +1711,7 @@ func validateInsecureRegistry() { func configureNodes(cc config.ClusterConfig, existing *config.ClusterConfig) (config.ClusterConfig, config.Node, error) { kv, err := getKubernetesVersion(&cc) if err != nil { - return cc, config.Node{}, errors.Wrapf(err, "failed getting kubernetes version") + return cc, config.Node{}, fmt.Errorf("failed getting kubernetes version: %w", err) } cr := getContainerRuntime(&cc) @@ -1739,7 +1740,7 @@ func configureNodes(cc config.ClusterConfig, existing *config.ClusterConfig) (co pcp, err := config.ControlPlane(*existing) if err != nil { - return cc, config.Node{}, errors.Wrapf(err, "failed getting control-plane node") + return cc, config.Node{}, fmt.Errorf("failed getting control-plane node: %w", err) } pcp.KubernetesVersion = kv pcp.ContainerRuntime = cr @@ -1760,7 +1761,7 @@ func autoSetDriverOptions(cmd *cobra.Command, drvName string) (err error) { klog.Infof("auto setting extra-config to %q.", eo) err = config.ExtraOptions.Set(eo) if err != nil { - err = errors.Wrapf(err, "setting extra option %s", eo) + err = fmt.Errorf("setting extra option %s: %w", eo, err) } } } @@ -1964,16 +1965,16 @@ func validateDockerStorageDriver(drvName string) { func validateSubnet(subnet string) error { ip, cidr, err := netutil.ParseAddr(subnet) if err != nil { - return errors.Errorf("Sorry, unable to parse subnet: %v", err) + return fmt.Errorf("Sorry, unable to parse subnet: %v", err) } if !ip.IsPrivate() { - return errors.Errorf("Sorry, the subnet %s is not a private IP", ip) + return fmt.Errorf("Sorry, the subnet %s is not a private IP", ip) } if cidr != nil { mask, _ := cidr.Mask.Size() if mask > 30 { - return errors.Errorf("Sorry, the subnet provided does not have a mask less than or equal to /30") + return fmt.Errorf("Sorry, the subnet provided does not have a mask less than or equal to /30") } } return nil @@ -2049,10 +2050,10 @@ func exitIfNotForced(r reason.Kind, message string, v ...out.V) { } func exitGuestProvision(err error) { - if errors.Cause(err) == oci.ErrInsufficientDockerStorage { + if errors.Is(err, oci.ErrInsufficientDockerStorage) { exit.Message(reason.RsrcInsufficientDockerStorage, "preload extraction failed: \"No space left on device\"") } - if errors.Cause(err) == oci.ErrGetSSHPortContainerNotRunning { + if errors.Is(err, oci.ErrGetSSHPortContainerNotRunning) { exit.Message(reason.GuestProvisionContainerExited, "Docker container exited prematurely after it was created, consider investigating Docker's performance/health.") } exit.Error(reason.GuestProvision, "error provisioning guest", err) diff --git a/cmd/minikube/cmd/start_flags.go b/cmd/minikube/cmd/start_flags.go index 41ae41d809..0fa59e6185 100644 --- a/cmd/minikube/cmd/start_flags.go +++ b/cmd/minikube/cmd/start_flags.go @@ -23,7 +23,6 @@ import ( "time" "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/shirou/gopsutil/v4/cpu" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -327,7 +326,7 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k // identify appropriate cni then configure cruntime accordingly if _, err := cni.New(&cc); err != nil { - return cc, config.Node{}, errors.Wrap(err, "cni") + return cc, config.Node{}, fmt.Errorf("cni: %w", err) } } else { klog.Info("no existing cluster config was found, will generate one from the flags ") @@ -335,7 +334,7 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k cnm, err := cni.New(&cc) if err != nil { - return cc, config.Node{}, errors.Wrap(err, "cni") + return cc, config.Node{}, fmt.Errorf("cni: %w", err) } if _, ok := cnm.(cni.Disabled); !ok { @@ -346,7 +345,7 @@ func generateClusterConfig(cmd *cobra.Command, existing *config.ClusterConfig, k r, err := cruntime.New(cruntime.Config{Type: cc.KubernetesConfig.ContainerRuntime}) if err != nil { - return cc, config.Node{}, errors.Wrap(err, "new runtime manager") + return cc, config.Node{}, fmt.Errorf("new runtime manager: %w", err) } // Feed Docker our host proxy environment by default, so that it can pull images diff --git a/cmd/minikube/cmd/status.go b/cmd/minikube/cmd/status.go index 1c13577ccd..6608d652a6 100644 --- a/cmd/minikube/cmd/status.go +++ b/cmd/minikube/cmd/status.go @@ -25,7 +25,6 @@ import ( "text/template" "time" - "github.com/pkg/errors" "github.com/spf13/cobra" "k8s.io/klog/v2" "k8s.io/minikube/cmd/minikube/cmd/flags" @@ -227,7 +226,7 @@ func clusterStatusJSON(statuses []*cluster.Status, w io.Writer, cc *config.Clust bs, err := json.Marshal(cs) if err != nil { - return errors.Wrap(err, "marshal") + return fmt.Errorf("marshal: %w", err) } _, err = w.Write(bs) diff --git a/cmd/minikube/cmd/stop.go b/cmd/minikube/cmd/stop.go index 791bc8f5a3..945e91c61b 100644 --- a/cmd/minikube/cmd/stop.go +++ b/cmd/minikube/cmd/stop.go @@ -21,7 +21,8 @@ import ( "runtime" "time" - "github.com/pkg/errors" + "errors" + "github.com/spf13/cobra" "github.com/spf13/viper" "k8s.io/klog/v2" @@ -167,14 +168,15 @@ func stop(api libmachine.API, machineName string) bool { } klog.Warningf("stop host returned error: %v", err) - switch err := errors.Cause(err).(type) { - case mcnerror.ErrHostDoesNotExist: + klog.Warningf("stop host returned error: %v", err) + + var e mcnerror.ErrHostDoesNotExist + if errors.As(err, &e) { out.Styled(style.Meh, `"{{.machineName}}" does not exist, nothing to stop`, out.V{"machineName": machineName}) nonexistent = true return nil - default: - return err } + return err } if err := retry.Expo(tryStop, 1*time.Second, 120*time.Second, 5); err != nil { diff --git a/cmd/performance/pr-bot/bot.go b/cmd/performance/pr-bot/bot.go index 106c446f4b..8c6be10b74 100644 --- a/cmd/performance/pr-bot/bot.go +++ b/cmd/performance/pr-bot/bot.go @@ -22,7 +22,6 @@ import ( "log" "time" - "github.com/pkg/errors" "k8s.io/minikube/pkg/perf/monitor" ) @@ -44,7 +43,7 @@ func analyzePerformance(ctx context.Context) error { client := monitor.NewClient(ctx, monitor.GithubOwner, monitor.GithubRepo) prs, err := client.ListOpenPRsWithLabel(monitor.OkToTestLabel) if err != nil { - return errors.Wrap(err, "listing open prs") + return fmt.Errorf("listing open prs: %w", err) } log.Print("got prs:", prs) for _, pr := range prs { diff --git a/go.mod b/go.mod index ad4a4196e2..b82dfd9608 100644 --- a/go.mod +++ b/go.mod @@ -48,7 +48,6 @@ require ( github.com/otiai10/copy v1.14.1 github.com/phayes/freeport v0.0.0-20180830031419-95f893ade6f2 github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 - github.com/pkg/errors v0.9.1 github.com/pkg/profile v1.7.0 github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 github.com/shirou/gopsutil/v4 v4.25.12 @@ -199,6 +198,7 @@ require ( github.com/otiai10/mint v1.6.3 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/pierrec/lz4/v4 v4.1.17 // indirect + github.com/pkg/errors v0.9.1 // indirect github.com/pkg/xattr v0.4.9 // indirect github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect diff --git a/hack/benchmark/cpu_usage/auto_pause/chart.go b/hack/benchmark/cpu_usage/auto_pause/chart.go index 86c618136b..4775a7ee9f 100644 --- a/hack/benchmark/cpu_usage/auto_pause/chart.go +++ b/hack/benchmark/cpu_usage/auto_pause/chart.go @@ -26,7 +26,7 @@ import ( "runtime" "strconv" - "github.com/pkg/errors" + "errors" "gonum.org/v1/plot" "gonum.org/v1/plot/plotter" "gonum.org/v1/plot/plotutil" @@ -77,7 +77,7 @@ func execute() error { napFn := "./out/benchmark-results/" + sessionID + "/cstat.nonautopause.summary" napFile, err := os.Open(napFn) if err != nil { - return errors.Wrap(err, "Missing summary csv") + return fmt.Errorf("Missing summary csv: %w", err) } defer napFile.Close() @@ -92,7 +92,7 @@ func execute() error { s, err := strconv.ParseFloat(napLine[0], 64) if err != nil { - return errors.Wrap(err, "Failed to convert to float64") + return fmt.Errorf("Failed to convert to float64: %w", err) } napResults = append(napResults, s) } @@ -102,7 +102,7 @@ func execute() error { apFn := "./out/benchmark-results/" + sessionID + "/cstat.autopause.summary" apFile, err := os.Open(apFn) if err != nil { - return errors.Wrap(err, "Missing summary csv") + return fmt.Errorf("Missing summary csv: %w", err) } defer apFile.Close() @@ -117,7 +117,7 @@ func execute() error { s, err := strconv.ParseFloat(apLine[0], 64) if err != nil { - return errors.Wrap(err, "Failed to convert to float64") + return fmt.Errorf("Failed to convert to float64: %w", err) } apResults = append(apResults, s) } @@ -128,7 +128,7 @@ func execute() error { // Create Bar instance with non-autopause benchmark results barNAP, err := plotter.NewBarChart(plotter.Values(napResults), breadth) if err != nil { - return errors.Wrap(err, "Failed to create bar chart") + return fmt.Errorf("Failed to create bar chart: %w", err) } // Set border of the bar graph. 0 is no border color @@ -141,7 +141,7 @@ func execute() error { // Create Bar instance with auto-pause benchmark results barAP, err := plotter.NewBarChart(plotter.Values(apResults), breadth) if err != nil { - return errors.Wrap(err, "Failed to create bar chart") + return fmt.Errorf("Failed to create bar chart: %w", err) } // Set border of the bar graph. 0 is no border color @@ -229,12 +229,12 @@ func execute() error { switch runtime.GOOS { case "darwin": if err := p.Save(13*vg.Inch, 8*vg.Inch, FOLDER+"/mac.png"); err != nil { - return errors.Wrap(err, "Failed to create bar graph png") + return fmt.Errorf("Failed to create bar graph png: %w", err) } log.Printf("Generated graph png to %s/mac.png", FOLDER) case "linux": if err := p.Save(13*vg.Inch, 10*vg.Inch, FOLDER+"/linux.png"); err != nil { - return errors.Wrap(err, "Failed to create bar graph png") + return fmt.Errorf("Failed to create bar graph png: %w", err) } log.Printf("Generated graph png to %s/linux.png", FOLDER) } diff --git a/hack/benchmark/cpu_usage/idle_only/chart.go b/hack/benchmark/cpu_usage/idle_only/chart.go index aaf466b67c..8de782cd01 100644 --- a/hack/benchmark/cpu_usage/idle_only/chart.go +++ b/hack/benchmark/cpu_usage/idle_only/chart.go @@ -25,7 +25,7 @@ import ( "runtime" "strconv" - "github.com/pkg/errors" + "errors" "gonum.org/v1/plot" "gonum.org/v1/plot/plotter" "gonum.org/v1/plot/plotutil" @@ -76,7 +76,7 @@ func execute() error { fn := "./out/benchmark-results/" + sessionID + "/cstat.summary" file, err := os.Open(fn) if err != nil { - return errors.Wrap(err, "Missing summary csv") + return fmt.Errorf("Missing summary csv: %w", err) } defer file.Close() @@ -91,7 +91,7 @@ func execute() error { s, err := strconv.ParseFloat(line[0], 64) if err != nil { - return errors.Wrap(err, "Failed to convert to float64") + return fmt.Errorf("Failed to convert to float64: %w", err) } results = append(results, s) } @@ -101,7 +101,7 @@ func execute() error { // Create Bar instance with benchmark results bar, err := plotter.NewBarChart(plotter.Values(results), breadth) if err != nil { - return errors.Wrap(err, "Failed to create bar chart") + return fmt.Errorf("Failed to create bar chart: %w", err) } // Set border of the bar graph. 0 is no border color @@ -157,12 +157,12 @@ func execute() error { switch runtime.GOOS { case "darwin": if err := p.Save(13*vg.Inch, 8*vg.Inch, FOLDER+"/mac.png"); err != nil { - return errors.Wrap(err, "Failed to create bar graph png") + return fmt.Errorf("Failed to create bar graph png: %w", err) } log.Printf("Generated graph png to %s/mac.png", FOLDER) case "linux": if err := p.Save(13*vg.Inch, 10*vg.Inch, FOLDER+"/linux.png"); err != nil { - return errors.Wrap(err, "Failed to create bar graph png") + return fmt.Errorf("Failed to create bar graph png: %w", err) } log.Printf("Generated graph png to %s/linux.png", FOLDER) } diff --git a/hack/kicbase_version/release_kicbase_version.go b/hack/kicbase_version/release_kicbase_version.go index 96c19848c5..8b8c99ba04 100644 --- a/hack/kicbase_version/release_kicbase_version.go +++ b/hack/kicbase_version/release_kicbase_version.go @@ -54,7 +54,7 @@ import ( "k8s.io/klog/v2" - "github.com/pkg/errors" + "errors" ) const ( @@ -93,7 +93,7 @@ var ( var out bytes.Buffer cmd.Stderr = &out if err := cmd.Run(); err != nil { - return errors.Errorf("%s: %s", err.Error(), out.String()) + return fmt.Errorf("%s: %s", err.Error(), out.String()) } return nil } @@ -205,7 +205,7 @@ func prepareImage(ctx context.Context, current, release string) (image string, e } } if image == "" { - return "", errors.Errorf("cannot find current image version tag %s locally nor in any registry", current) + return "", fmt.Errorf("cannot find current image version tag %s locally nor in any registry", current) } // tag current image with release version tag := exec.CommandContext(ctx, "docker", "tag", image+":"+current, image+":"+release) diff --git a/hack/metrics/metrics.go b/hack/metrics/metrics.go index a338ed67a9..4b4899c7bb 100644 --- a/hack/metrics/metrics.go +++ b/hack/metrics/metrics.go @@ -27,8 +27,8 @@ import ( "time" _ "cloud.google.com/go/storage" + "errors" mexporter "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric" - "github.com/pkg/errors" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/metric" sdkmetric "go.opentelemetry.io/otel/sdk/metric" @@ -65,7 +65,7 @@ func execute() error { } ctx := context.Background() if err := downloadMinikube(ctx, tmpFile); err != nil { - return errors.Wrap(err, "downloading minikube") + return fmt.Errorf("downloading minikube: %w", err) } for _, cr := range []string{"docker", "containerd", "crio"} { @@ -79,19 +79,19 @@ func execute() error { func exportMinikubeStart(ctx context.Context, projectID, containerRuntime string) error { mp, attrs, err := getMeterProvider(projectID, containerRuntime) if err != nil { - return errors.Wrap(err, "creating meter provider") + return fmt.Errorf("creating meter provider: %w", err) } defer func() { _ = mp.Shutdown(ctx) }() meter := mp.Meter("minikube") latency, err := meter.Float64Histogram(customMetricName) if err != nil { - return errors.Wrap(err, "creating histogram") + return fmt.Errorf("creating histogram: %w", err) } st, err := minikubeStartTime(ctx, projectID, tmpFile, containerRuntime) if err != nil { - return errors.Wrap(err, "collecting start time") + return fmt.Errorf("collecting start time: %w", err) } fmt.Printf("Latency: %f\n", st) latency.Record(ctx, st, metric.WithAttributes(attrs...)) @@ -137,7 +137,7 @@ func minikubeStartTime(ctx context.Context, projectID, minikubePath, containerRu t := time.Now() log.Printf("Running [%v]....", cmd.Args) if err := cmd.Run(); err != nil { - return 0, errors.Wrapf(err, "running %v", cmd.Args) + return 0, fmt.Errorf("running %v: %w", cmd.Args, err) } totalTime := time.Since(t).Seconds() return totalTime, nil diff --git a/hack/metrics/minikube.go b/hack/metrics/minikube.go index f2fcbf98bb..d006ca513d 100644 --- a/hack/metrics/minikube.go +++ b/hack/metrics/minikube.go @@ -28,7 +28,7 @@ import ( "log" "cloud.google.com/go/storage" - "github.com/pkg/errors" + "errors" ) const ( @@ -39,7 +39,7 @@ const ( func downloadMinikube(ctx context.Context, minikubePath string) error { client, err := storage.NewClient(ctx) if err != nil { - return errors.Wrap(err, "creating client") + return fmt.Errorf("creating client: %w", err) } obj := client.Bucket("minikube").Object(fmt.Sprintf("latest/%s", binary())) @@ -52,20 +52,20 @@ func downloadMinikube(ctx context.Context, minikubePath string) error { // download minikube binary from GCS rc, err := obj.NewReader(ctx) if err != nil { - return errors.Wrap(err, "gcs new reader") + return fmt.Errorf("gcs new reader: %w", err) } defer rc.Close() data, err := io.ReadAll(rc) if err != nil { - return errors.Wrap(err, "io read all") + return fmt.Errorf("io read all: %w", err) } log.Printf("downloading gs://%s/%s to %v", bucketName, binary(), minikubePath) if err := os.WriteFile(minikubePath, data, 0777); err != nil { - return errors.Wrap(err, "writing minikubePath") + return fmt.Errorf("writing minikubePath: %w", err) } if err := os.Chmod(minikubePath, 0700); err != nil { - return errors.Wrap(err, "chmod") + return fmt.Errorf("chmod: %w", err) } return nil } diff --git a/hack/preload-images/generate.go b/hack/preload-images/generate.go index 7f59d1a517..c20325b916 100644 --- a/hack/preload-images/generate.go +++ b/hack/preload-images/generate.go @@ -23,7 +23,7 @@ import ( "path/filepath" "time" - "github.com/pkg/errors" + "errors" "k8s.io/minikube/pkg/drivers/kic" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/minikube/bootstrapper/bsutil" @@ -56,16 +56,16 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string defer os.Remove(baseDir) if err := os.MkdirAll(baseDir, 0755); err != nil { - return errors.Wrap(err, "mkdir") + return fmt.Errorf("mkdir: %w", err) } if err := driver.Create(); err != nil { - return errors.Wrap(err, "creating kic driver") + return fmt.Errorf("creating kic driver: %w", err) } // Now, get images to pull imgs, err := images.Kubeadm("", kubernetesVersion) if err != nil { - return errors.Wrap(err, "kubeadm images") + return fmt.Errorf("kubeadm images: %w", err) } if containerRuntime != "docker" { // kic overlay image is only needed by containerd and cri-o https://github.com/kubernetes/minikube/issues/7428 @@ -77,7 +77,7 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string // will need to do this to enable the container run-time service sv, err := util.ParseKubernetesVersion(kubernetesVersion) if err != nil { - return errors.Wrap(err, "Failed to parse Kubernetes version") + return fmt.Errorf("Failed to parse Kubernetes version: %w", err) } co := cruntime.Config{ @@ -88,16 +88,16 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string } cr, err := cruntime.New(co) if err != nil { - return errors.Wrap(err, "failed create new runtime") + return fmt.Errorf("failed create new runtime: %w", err) } if err := cr.Enable(true, detect.CgroupDriver(), false); err != nil { - return errors.Wrap(err, "enable container runtime") + return fmt.Errorf("enable container runtime: %w", err) } // Verify storage driver/snapshotter after the runtime has been configured. if err := verifyStorage(containerRuntime); err != nil { - return errors.Wrap(err, "verifying storage") + return fmt.Errorf("verifying storage: %w", err) } for _, img := range imgs { @@ -107,13 +107,13 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string cmd.Stderr = os.Stderr if err := cmd.Run(); err != nil { time.Sleep(time.Second) // to avoid error: : exec: already started - return errors.Wrapf(err, "pulling image %s", img) + return fmt.Errorf("pulling image %s: %w", img, err) } return nil } // retry up to 5 times if network is bad if err = retry.Expo(pull, time.Microsecond, time.Minute, 5); err != nil { - return errors.Wrapf(err, "pull image %s", img) + return fmt.Errorf("pull image %s: %w", img, err) } } @@ -126,11 +126,11 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string sm := sysinit.New(runner) if err := bsutil.TransferBinaries(kcfg, runner, sm, ""); err != nil { - return errors.Wrap(err, "transferring k8s binaries") + return fmt.Errorf("transferring k8s binaries: %w", err) } // Create image tarball if err := createImageTarball(tarballFilename, containerRuntime); err != nil { - return errors.Wrap(err, "create tarball") + return fmt.Errorf("create tarball: %w", err) } return copyTarballToHost(tarballFilename) @@ -139,17 +139,17 @@ func generateTarball(kubernetesVersion, containerRuntime, tarballFilename string func verifyStorage(containerRuntime string) error { if containerRuntime == "docker" { if err := retry.Expo(verifyDockerStorage, 100*time.Microsecond, time.Minute*2); err != nil { - return errors.Wrap(err, "Docker storage type is incompatible") + return fmt.Errorf("Docker storage type is incompatible: %w", err) } } if containerRuntime == "containerd" { if err := retry.Expo(verifyContainerdStorage, 100*time.Microsecond, time.Minute*2); err != nil { - return errors.Wrap(err, "containerd storage type is incompatible") + return fmt.Errorf("containerd storage type is incompatible: %w", err) } } if containerRuntime == "cri-o" { if err := retry.Expo(verifyPodmanStorage, 100*time.Microsecond, time.Minute*2); err != nil { - return errors.Wrap(err, "Podman storage type is incompatible") + return fmt.Errorf("Podman storage type is incompatible: %w", err) } } return nil @@ -194,7 +194,7 @@ func createImageTarball(tarballFilename, containerRuntime string) error { cmd := exec.Command("docker", args...) cmd.Stdout = os.Stdout if err := cmd.Run(); err != nil { - return errors.Wrapf(err, "tarball cmd: %s", cmd.Args) + return fmt.Errorf("tarball cmd: %s: %w", cmd.Args, err) } return nil } @@ -204,7 +204,7 @@ func copyTarballToHost(tarballFilename string) error { cmd := exec.Command("docker", "cp", fmt.Sprintf("%s:/%s", profile, tarballFilename), dest) cmd.Stdout = os.Stdout if err := cmd.Run(); err != nil { - return errors.Wrapf(err, "cp cmd: %s", cmd.Args) + return fmt.Errorf("cp cmd: %s: %w", cmd.Args, err) } return nil } diff --git a/hack/preload-images/preload_images.go b/hack/preload-images/preload_images.go index 3c04d7d5ef..0a585d48f6 100644 --- a/hack/preload-images/preload_images.go +++ b/hack/preload-images/preload_images.go @@ -27,7 +27,7 @@ import ( "runtime/debug" "strings" - "github.com/pkg/errors" + "errors" "github.com/spf13/viper" "k8s.io/minikube/pkg/minikube/constants" @@ -152,7 +152,7 @@ func makePreload(cfg preloadCfg) error { }() if err := generateTarball(kv, cr, tf); err != nil { - return errors.Wrap(err, fmt.Sprintf("generating tarball for k8s version %s with %s", kv, cr)) + return fmt.Errorf("%s: %w", fmt.Sprintf("generating tarball for k8s version %s with %s", kv, cr), err) } if *noUpload { @@ -160,7 +160,7 @@ func makePreload(cfg preloadCfg) error { return nil } if err := uploadTarballToGCS(tf, kv); err != nil { - return errors.Wrap(err, fmt.Sprintf("uploading tarball for k8s version %s with %s", kv, cr)) + return fmt.Errorf("%s: %w", fmt.Sprintf("uploading tarball for k8s version %s with %s", kv, cr), err) } return nil } diff --git a/hack/preload-images/upload.go b/hack/preload-images/upload.go index ed4386343b..086d20575c 100644 --- a/hack/preload-images/upload.go +++ b/hack/preload-images/upload.go @@ -22,7 +22,7 @@ import ( "path" "strings" - "github.com/pkg/errors" + "errors" "k8s.io/minikube/pkg/minikube/download" ) @@ -33,7 +33,7 @@ func uploadTarball(tarballFilename, k8sVer string) error { cmd := exec.Command("gsutil", "cp", hostPath, gcsDest) fmt.Printf("Running: %v\n", cmd.Args) if output, err := cmd.CombinedOutput(); err != nil { - return errors.Wrapf(err, "uploading %s to GCS bucket: %v\n%s", hostPath, err, string(output)) + return fmt.Errorf("uploading %s to GCS bucket: %v\n%s: %w", hostPath, err, string(output), err) } return nil } @@ -56,7 +56,7 @@ func uploadArmTarballs(preloadsDir string) error { cmd := exec.Command("gsutil", "cp", hostPath, gcsDest) fmt.Printf("Running: %v\n", cmd.Args) if output, err := cmd.CombinedOutput(); err != nil { - return errors.Wrapf(err, "uploading %s to GCS bucket: %v\n%s", hostPath, err, string(output)) + return fmt.Errorf("uploading %s to GCS bucket: %v\n%s: %w", hostPath, err, string(output), err) } } return nil diff --git a/hack/rewrite_pkg_errors.go b/hack/rewrite_pkg_errors.go new file mode 100644 index 0000000000..0dbca76cf0 --- /dev/null +++ b/hack/rewrite_pkg_errors.go @@ -0,0 +1,159 @@ +package main + +import ( + "fmt" + "go/ast" + "go/format" + "go/parser" + "go/token" + "io/fs" + "log" + "os" + "path/filepath" + "strings" +) + +func main() { + filesProcessed := 0 + filesModified := 0 + skippedCalls := 0 + + err := filepath.Walk(".", func(path string, info fs.FileInfo, err error) error { + if err != nil { + return err + } + if !strings.HasSuffix(path, ".go") { + return nil + } + if strings.Contains(path, "vendor/") { + return nil + } + if info.IsDir() { + if info.Name() == "vendor" || info.Name() == ".git" { + return filepath.SkipDir + } + return nil + } + // Skip self + if strings.Contains(path, "rewrite_pkg_errors.go") { + return nil + } + + fset := token.NewFileSet() + node, err := parser.ParseFile(fset, path, nil, parser.ParseComments) + if err != nil { + return nil + } + + usesPkgErrors := false + for _, imp := range node.Imports { + if imp.Path.Value == "\"github.com/pkg/errors\"" { + usesPkgErrors = true + imp.Path.Value = "\"errors\"" + } + } + + if !usesPkgErrors { + return nil + } + filesProcessed++ + + rewritten := false + + ast.Inspect(node, func(n ast.Node) bool { + call, ok := n.(*ast.CallExpr) + if !ok { + return true + } + sel, ok := call.Fun.(*ast.SelectorExpr) + if !ok { + return true + } + ident, ok := sel.X.(*ast.Ident) + if !ok || ident.Name != "errors" { + return true + } + + if sel.Sel.Name == "Wrap" || sel.Sel.Name == "Wrapf" { + if len(call.Args) < 2 { + return true + } + errArg := call.Args[0] + + // Safety Check: If errArg is a function call, replacing with fmt.Errorf is UNSAFE + if _, isCall := errArg.(*ast.CallExpr); isCall { + fmt.Printf("WARNING: Skipping unsafe errors.%s rewrite in %s line %d: error arg is a function call\n", + sel.Sel.Name, path, fset.Position(call.Pos()).Line) + skippedCalls++ + // Reset import (partial fix might leave file broken if we don't fix this call) + // But we already changed the import in the loop above. + // We will manually fix these. + return true + } + + // errors.Wrap(err, "msg") -> fmt.Errorf("msg: %w", err) + msgIndex := 1 + restArgs := call.Args[2:] + + ident.Name = "fmt" + sel.Sel.Name = "Errorf" + + msgArg := call.Args[msgIndex] + + if lit, ok := msgArg.(*ast.BasicLit); ok && lit.Kind == token.STRING { + val := lit.Value + if len(val) >= 2 { + inner := val[1 : len(val)-1] + newVal := fmt.Sprintf("\"%s: %%w\"", inner) + lit.Value = newVal + + newArgs := []ast.Expr{lit} + newArgs = append(newArgs, restArgs...) + newArgs = append(newArgs, errArg) + call.Args = newArgs + rewritten = true + return true + } + } + + if len(restArgs) == 0 { + fmtStr := &ast.BasicLit{Kind: token.STRING, Value: "\"%s: %w\""} + call.Args = []ast.Expr{fmtStr, msgArg, errArg} + rewritten = true + } else { + fmt.Printf("WARNING: Skipped complex errors.Wrapf in %s line %d\n", path, fset.Position(call.Pos()).Line) + skippedCalls++ + ident.Name = "errors" + sel.Sel.Name = "Wrapf" + } + } else if sel.Sel.Name == "Errorf" { + ident.Name = "fmt" + rewritten = true + } + + return true + }) + + if rewritten || usesPkgErrors { + // Even if we didn't rewrite any calls (e.g. only errors.New or skipped calls), + // we changed the import path to "errors". + // If we skipped calls, the file will fail to compile (errors.Wrap not defined). + // This is desired so we find them. + f, err := os.Create(path) + if err != nil { + return err + } + if err := format.Node(f, fset, node); err != nil { + f.Close() + return err + } + f.Close() + filesModified++ + } + return nil + }) + if err != nil { + log.Fatal(err) + } + fmt.Printf("Processed %d files, modified %d files, skipped %d calls\n", filesProcessed, filesModified, skippedCalls) +} diff --git a/pkg/addons/addons.go b/pkg/addons/addons.go index a2d456f2f7..676a9edb6a 100644 --- a/pkg/addons/addons.go +++ b/pkg/addons/addons.go @@ -28,8 +28,9 @@ import ( "sync" "time" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/minikube/pkg/libmachine/state" @@ -70,7 +71,7 @@ func RunCallbacks(cc *config.ClusterConfig, name string, value string, options * klog.Infof("Setting %s=%s in profile %q", name, value, cc.Name) a, valid := isAddonValid(name) if !valid { - return errors.Errorf("%s is not a valid addon", name) + return fmt.Errorf("%s is not a valid addon", name) } // Run any additional validations for this property @@ -78,7 +79,7 @@ func RunCallbacks(cc *config.ClusterConfig, name string, value string, options * if errors.Is(err, ErrSkipThisAddon) { return err } - return errors.Wrap(err, "running validations") + return fmt.Errorf("running validations: %w", err) } preStartMessages(name, value) @@ -88,7 +89,7 @@ func RunCallbacks(cc *config.ClusterConfig, name string, value string, options * if errors.Is(err, ErrSkipThisAddon) { return err } - return errors.Wrap(err, "running callbacks") + return fmt.Errorf("running callbacks: %w", err) } postStartMessages(cc, name, value) @@ -176,7 +177,7 @@ func Deprecations(name string) (bool, string, string) { func Set(cc *config.ClusterConfig, name string, value string, options *run.CommandOptions) error { a, valid := isAddonValid(name) if !valid { - return errors.Errorf("%s is not a valid addon", name) + return fmt.Errorf("%s is not a valid addon", name) } return a.set(cc, name, value, options) } @@ -185,18 +186,18 @@ func Set(cc *config.ClusterConfig, name string, value string, options *run.Comma func SetAndSave(profile string, name string, value string, options *run.CommandOptions) error { cc, err := config.Load(profile) if err != nil { - return errors.Wrap(err, "loading profile") + return fmt.Errorf("loading profile: %w", err) } if err := RunCallbacks(cc, name, value, options); err != nil { if errors.Is(err, ErrSkipThisAddon) { return err } - return errors.Wrap(err, "run callbacks") + return fmt.Errorf("run callbacks: %w", err) } if err := Set(cc, name, value, options); err != nil { - return errors.Wrap(err, "set") + return fmt.Errorf("set: %w", err) } klog.Infof("Writing out %q config to set %s=%v...", profile, name, value) @@ -239,7 +240,7 @@ func EnableOrDisableAddon(cc *config.ClusterConfig, name string, val string, opt klog.Infof("Setting addon %s=%s in %q", name, val, cc.Name) enable, err := strconv.ParseBool(val) if err != nil { - return errors.Wrapf(err, "parsing bool: %s", name) + return fmt.Errorf("parsing bool: %s: %w", name, err) } addon := assets.Addons[name] @@ -253,7 +254,7 @@ func EnableOrDisableAddon(cc *config.ClusterConfig, name string, val string, opt api, err := machine.NewAPIClient(options) if err != nil { - return errors.Wrap(err, "machine client") + return fmt.Errorf("machine client: %w", err) } defer api.Close() @@ -288,7 +289,7 @@ func EnableOrDisableAddon(cc *config.ClusterConfig, name string, val string, opt runner, err := machine.CommandRunner(host) if err != nil { - return errors.Wrap(err, "command runner") + return fmt.Errorf("command runner: %w", err) } bail, err := addonSpecificChecks(cc, name, enable, runner) @@ -336,7 +337,7 @@ func addonSpecificChecks(cc *config.ClusterConfig, name string, enable bool, run if driver.NeedsPortForward(cc.Driver) { port, err := oci.ForwardedPort(cc.Driver, cc.Name, constants.RegistryAddonPort) if err != nil { - return false, errors.Wrap(err, "registry port") + return false, fmt.Errorf("registry port: %w", err) } if enable { out.Boxed(`Registry addon with {{.driver}} driver uses port {{.port}} please use that instead of default port 5000`, out.V{"driver": cc.Driver, "port": port}) @@ -386,7 +387,7 @@ func isAddonAlreadySet(cc *config.ClusterConfig, addon *assets.Addon, enable boo func supportLegacyIngress(addon *assets.Addon, cc config.ClusterConfig) error { v, err := util.ParseKubernetesVersion(cc.KubernetesConfig.KubernetesVersion) if err != nil { - return errors.Wrap(err, "parsing Kubernetes version") + return fmt.Errorf("parsing Kubernetes version: %w", err) } if semver.MustParseRange("<1.19.0")(v) { if addon.Name() == "ingress" { @@ -424,7 +425,7 @@ func enableOrDisableAddonInternal(cc *config.ClusterConfig, addon *assets.Addon, if addon.IsTemplate() { f, err = addon.Evaluate(data) if err != nil { - return errors.Wrapf(err, "evaluate bundled addon %s asset", addon.GetSourcePath()) + return fmt.Errorf("evaluate bundled addon %s asset: %w", addon.GetSourcePath(), err) } } else { @@ -495,7 +496,7 @@ func verifyAddonStatusInternal(cc *config.ClusterConfig, name string, val string klog.Infof("Verifying addon %s=%s in %q", name, val, cc.Name) enable, err := strconv.ParseBool(val) if err != nil { - return errors.Wrapf(err, "parsing bool: %s", name) + return fmt.Errorf("parsing bool: %s: %w", name, err) } label, ok := addonPodLabels[name] @@ -503,13 +504,13 @@ func verifyAddonStatusInternal(cc *config.ClusterConfig, name string, val string out.Step(style.HealthCheck, "Verifying {{.addon_name}} addon...", out.V{"addon_name": name}) client, err := kapi.Client(viper.GetString(config.ProfileName)) if err != nil { - return errors.Wrapf(err, "get kube-client to validate %s addon: %v", name, err) + return fmt.Errorf("get kube-client to validate %s addon: %v: %w", name, err, err) } // This timeout includes image pull time, which can take a few minutes. 3 is not enough. err = kapi.WaitForPods(client, ns, label, time.Minute*6) if err != nil { - return errors.Wrapf(err, "waiting for %s pods", label) + return fmt.Errorf("waiting for %s pods: %w", label, err) } } @@ -623,28 +624,28 @@ func VerifyNotPaused(profile string, enable bool, options *run.CommandOptions) e cc, err := config.Load(profile) if err != nil { - return errors.Wrap(err, "loading profile") + return fmt.Errorf("loading profile: %w", err) } api, err := machine.NewAPIClient(options) if err != nil { - return errors.Wrap(err, "machine client") + return fmt.Errorf("machine client: %w", err) } defer api.Close() cp, err := config.ControlPlane(*cc) if err != nil { - return errors.Wrap(err, "get control-plane node") + return fmt.Errorf("get control-plane node: %w", err) } host, err := machine.LoadHost(api, config.MachineName(*cc, cp)) if err != nil { - return errors.Wrap(err, "get host") + return fmt.Errorf("get host: %w", err) } s, err := host.Driver.GetState() if err != nil { - return errors.Wrap(err, "get state") + return fmt.Errorf("get state: %w", err) } if s != state.Running { // can't check the status of pods on a non-running cluster @@ -653,17 +654,17 @@ func VerifyNotPaused(profile string, enable bool, options *run.CommandOptions) e runner, err := machine.CommandRunner(host) if err != nil { - return errors.Wrap(err, "command runner") + return fmt.Errorf("command runner: %w", err) } crName := cc.KubernetesConfig.ContainerRuntime cr, err := cruntime.New(cruntime.Config{Type: crName, Runner: runner}) if err != nil { - return errors.Wrap(err, "container runtime") + return fmt.Errorf("container runtime: %w", err) } runtimePaused, err := cluster.CheckIfPaused(cr, []string{"kube-system"}) if err != nil { - return errors.Wrap(err, "check paused") + return fmt.Errorf("check paused: %w", err) } if !runtimePaused { return nil diff --git a/pkg/addons/addons_autopause.go b/pkg/addons/addons_autopause.go index 0a754f1b00..15e4e3fc77 100644 --- a/pkg/addons/addons_autopause.go +++ b/pkg/addons/addons_autopause.go @@ -17,9 +17,9 @@ limitations under the License. package addons import ( + "fmt" "strconv" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/minikube/config" @@ -36,7 +36,7 @@ import ( func enableOrDisableAutoPause(cc *config.ClusterConfig, name, val string, options *run.CommandOptions) error { enable, err := strconv.ParseBool(val) if err != nil { - return errors.Wrapf(err, "parsing bool: %s", name) + return fmt.Errorf("parsing bool: %s: %w", name, err) } out.Infof("auto-pause addon is an alpha feature and still in early development. Please file issues to help us make it better.") out.Infof("https://github.com/kubernetes/minikube/labels/co/auto-pause") diff --git a/pkg/addons/addons_gcpauth.go b/pkg/addons/addons_gcpauth.go index 628f6c15e5..2beb39c244 100644 --- a/pkg/addons/addons_gcpauth.go +++ b/pkg/addons/addons_gcpauth.go @@ -29,7 +29,6 @@ import ( corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "github.com/pkg/errors" "golang.org/x/oauth2/google" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" @@ -58,7 +57,7 @@ const ( func enableOrDisableGCPAuth(cfg *config.ClusterConfig, name, val string, options *run.CommandOptions) error { enable, err := strconv.ParseBool(val) if err != nil { - return errors.Wrapf(err, "parsing bool: %s", name) + return fmt.Errorf("parsing bool: %s: %w", name, err) } if enable { return enableAddonGCPAuth(cfg, options) @@ -90,7 +89,7 @@ func enableAddonGCPAuth(cfg *config.ClusterConfig, options *run.CommandOptions) // Patch service accounts for all namespaces to include the image pull secret. // The image registry pull secret is added to the namespaces in the webhook. if err := patchServiceAccounts(cfg); err != nil { - return errors.Wrap(err, "patching service accounts") + return fmt.Errorf("patching service accounts: %w", err) } // If the env var is explicitly set, even in GCE, then defer to the user and continue @@ -307,7 +306,7 @@ func disableAddonGCPAuth(cfg *config.ClusterConfig, options *run.CommandOptions) func verifyGCPAuthAddon(cc *config.ClusterConfig, name, val string, options *run.CommandOptions) error { enable, err := strconv.ParseBool(val) if err != nil { - return errors.Wrapf(err, "parsing bool: %s", name) + return fmt.Errorf("parsing bool: %s: %w", name, err) } // If we're in GCE and didn't actually start the gcp-auth pods, don't check for them. diff --git a/pkg/addons/addons_storage_classes.go b/pkg/addons/addons_storage_classes.go index 61616e3237..98943ae80c 100644 --- a/pkg/addons/addons_storage_classes.go +++ b/pkg/addons/addons_storage_classes.go @@ -17,9 +17,9 @@ limitations under the License. package addons import ( + "fmt" "strconv" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/machine" @@ -34,7 +34,7 @@ func enableOrDisableStorageClasses(cc *config.ClusterConfig, name string, val st klog.Infof("enableOrDisableStorageClasses %s=%v on %q", name, val, cc.Name) enable, err := strconv.ParseBool(val) if err != nil { - return errors.Wrap(err, "Error parsing boolean") + return fmt.Errorf("Error parsing boolean: %w", err) } class := defaultStorageClassProvisioner @@ -44,13 +44,13 @@ func enableOrDisableStorageClasses(cc *config.ClusterConfig, name string, val st api, err := machine.NewAPIClient(options) if err != nil { - return errors.Wrap(err, "machine client") + return fmt.Errorf("machine client: %w", err) } defer api.Close() pcp, err := config.ControlPlane(*cc) if err != nil || !config.IsPrimaryControlPlane(*cc, pcp) { - return errors.Wrap(err, "get primary control-plane node") + return fmt.Errorf("get primary control-plane node: %w", err) } machineName := config.MachineName(*cc, pcp) if !machine.IsRunning(api, machineName) { @@ -60,7 +60,7 @@ func enableOrDisableStorageClasses(cc *config.ClusterConfig, name string, val st storagev1, err := storageclass.GetStoragev1(cc.Name) if err != nil { - return errors.Wrapf(err, "Error getting storagev1 interface %v ", err) + return fmt.Errorf("Error getting storagev1 interface %v : %w", err, err) } if enable { @@ -71,13 +71,13 @@ func enableOrDisableStorageClasses(cc *config.ClusterConfig, name string, val st // Only StorageClass for 'name' should be marked as default err = storageclass.SetDefaultStorageClass(storagev1, class) if err != nil { - return errors.Wrapf(err, "Error making %s the default storage class", class) + return fmt.Errorf("Error making %s the default storage class: %w", class, err) } } else { // Unset the StorageClass as default err := storageclass.DisableDefaultStorageClass(storagev1, class) if err != nil { - return errors.Wrapf(err, "Error disabling %s as the default storage class", class) + return fmt.Errorf("Error disabling %s as the default storage class: %w", class, err) } if err = EnableOrDisableAddon(cc, name, val, options); err != nil { return err diff --git a/pkg/addons/helm.go b/pkg/addons/helm.go index e257aa3bf2..60f3963ff7 100644 --- a/pkg/addons/helm.go +++ b/pkg/addons/helm.go @@ -22,7 +22,6 @@ import ( "os/exec" "path" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/command" "k8s.io/minikube/pkg/minikube/vmpath" @@ -80,19 +79,19 @@ func helmInstallBinary(addon *assets.Addon, runner command.Runner) error { if err != nil { _, err = runner.RunCmd(exec.Command("sudo", "mkdir", "-p", "/usr/local/bin")) if err != nil { - return errors.Wrap(err, "creating /usr/local/bin") + return fmt.Errorf("creating /usr/local/bin: %w", err) } } installCmd := "curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 && chmod 700 get_helm.sh && ./get_helm.sh" _, err = runner.RunCmd(exec.Command("sudo", "bash", "-c", installCmd)) if err != nil { - return errors.Wrap(err, "downloading helm") + return fmt.Errorf("downloading helm: %w", err) } // we copy the binary from /usr/local/bin to /usr/bin because /usr/local/bin is not in PATH in both iso and kicbase _, err = runner.RunCmd(exec.Command("sudo", "mv", "/usr/local/bin/helm", "/usr/bin/helm")) if err != nil { - return errors.Wrap(err, "installing helm") + return fmt.Errorf("installing helm: %w", err) } } return err diff --git a/pkg/drivers/common/common.go b/pkg/drivers/common/common.go index 74465f1e71..d600d34158 100644 --- a/pkg/drivers/common/common.go +++ b/pkg/drivers/common/common.go @@ -27,7 +27,6 @@ import ( "strings" "syscall" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" "k8s.io/minikube/pkg/libmachine/mcnflag" @@ -69,17 +68,17 @@ func CreateRawDisk(diskPath string, sizeMB int) error { if err != nil { if !os.IsNotExist(err) { // un-handle-able error stat-ing the disk file - return errors.Wrap(err, "stat") + return fmt.Errorf("stat: %w", err) } // disk file does not exist; create it file, err := os.OpenFile(diskPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644) if err != nil { - return errors.Wrap(err, "open") + return fmt.Errorf("open: %w", err) } defer file.Close() if err := file.Truncate(util.ConvertMBToBytes(sizeMB)); err != nil { - return errors.Wrap(err, "truncate") + return fmt.Errorf("truncate: %w", err) } } return nil @@ -108,27 +107,27 @@ func (d *CommonDriver) SetConfigFromFlags(_ drivers.DriverOptions) error { func createRawDiskImage(sshKeyPath, diskPath string, diskSizeMb int) error { tarBuf, err := mcnutils.MakeDiskImage(sshKeyPath) if err != nil { - return errors.Wrap(err, "make disk image") + return fmt.Errorf("make disk image: %w", err) } file, err := os.OpenFile(diskPath, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644) if err != nil { - return errors.Wrap(err, "open") + return fmt.Errorf("open: %w", err) } defer file.Close() if _, err := file.Seek(0, io.SeekStart); err != nil { - return errors.Wrap(err, "seek") + return fmt.Errorf("seek: %w", err) } if _, err := file.Write(tarBuf.Bytes()); err != nil { - return errors.Wrap(err, "write tar") + return fmt.Errorf("write tar: %w", err) } if err := file.Close(); err != nil { - return errors.Wrapf(err, "closing file %s", diskPath) + return fmt.Errorf("closing file %s: %w", diskPath, err) } if err := os.Truncate(diskPath, util.ConvertMBToBytes(diskSizeMb)); err != nil { - return errors.Wrap(err, "truncate") + return fmt.Errorf("truncate: %w", err) } return nil } @@ -152,24 +151,24 @@ func MakeDiskImage(d *drivers.BaseDriver, boot2dockerURL string, diskSize int) e klog.Infof("Making disk image using store path: %s", d.StorePath) b2 := mcnutils.NewB2dUtils(d.StorePath) if err := b2.CopyIsoToMachineDir(boot2dockerURL, d.MachineName); err != nil { - return errors.Wrap(err, "copy iso to machine dir") + return fmt.Errorf("copy iso to machine dir: %w", err) } keyPath := d.GetSSHKeyPath() klog.Infof("Creating ssh key: %s...", keyPath) if err := ssh.GenerateSSHKey(keyPath); err != nil { - return errors.Wrap(err, "generate ssh key") + return fmt.Errorf("generate ssh key: %w", err) } diskPath := GetDiskPath(d) klog.Infof("Creating raw disk image: %s...", diskPath) if _, err := os.Stat(diskPath); os.IsNotExist(err) { if err := createRawDiskImage(publicSSHKeyPath(d), diskPath, diskSize); err != nil { - return errors.Wrapf(err, "createRawDiskImage(%s)", diskPath) + return fmt.Errorf("createRawDiskImage(%s): %w", diskPath, err) } machPath := d.ResolveStorePath(".") if err := fixMachinePermissions(machPath); err != nil { - return errors.Wrapf(err, "fixing permissions on %s", machPath) + return fmt.Errorf("fixing permissions on %s: %w", machPath, err) } } return nil @@ -178,16 +177,16 @@ func MakeDiskImage(d *drivers.BaseDriver, boot2dockerURL string, diskSize int) e func fixMachinePermissions(path string) error { klog.Infof("Fixing permissions on %s ...", path) if err := os.Chown(path, syscall.Getuid(), syscall.Getegid()); err != nil { - return errors.Wrap(err, "chown dir") + return fmt.Errorf("chown dir: %w", err) } files, err := os.ReadDir(path) if err != nil { - return errors.Wrap(err, "read dir") + return fmt.Errorf("read dir: %w", err) } for _, f := range files { fp := filepath.Join(path, f.Name()) if err := os.Chown(fp, syscall.Getuid(), syscall.Getegid()); err != nil { - return errors.Wrap(err, "chown file") + return fmt.Errorf("chown file: %w", err) } } return nil diff --git a/pkg/drivers/hyperkit/driver.go b/pkg/drivers/hyperkit/driver.go index 1721058dc9..4eeb411ca4 100644 --- a/pkg/drivers/hyperkit/driver.go +++ b/pkg/drivers/hyperkit/driver.go @@ -31,9 +31,10 @@ import ( "syscall" "time" + pkgerrors "errors" + "github.com/johanneswuerbach/nfsexports" hyperkit "github.com/moby/hyperkit/go" - pkgerrors "github.com/pkg/errors" "github.com/shirou/gopsutil/v4/process" "k8s.io/minikube/pkg/drivers/common" "k8s.io/minikube/pkg/libmachine/drivers" diff --git a/pkg/drivers/hyperv/hyperv.go b/pkg/drivers/hyperv/hyperv.go index 821e71bd21..745a6afa43 100644 --- a/pkg/drivers/hyperv/hyperv.go +++ b/pkg/drivers/hyperv/hyperv.go @@ -25,7 +25,7 @@ import ( "strings" "time" - "github.com/pkg/errors" + "errors" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" diff --git a/pkg/drivers/kic/kic.go b/pkg/drivers/kic/kic.go index 4154a3b862..143d6ceb5e 100644 --- a/pkg/drivers/kic/kic.go +++ b/pkg/drivers/kic/kic.go @@ -27,7 +27,6 @@ import ( "sync" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/ssh" @@ -173,12 +172,12 @@ func (d *Driver) Create() error { } else { // The conflicting container name was not created by minikube // user has a container that conflicts with minikube profile name, will not delete users container. - return errors.Wrapf(err, "user has a conflicting container name %q with minikube container. Needs to be deleted by user's consent", params.Name) + return fmt.Errorf("user has a conflicting container name %q with minikube container. Needs to be deleted by user's consent: %w", params.Name, err) } } if err := oci.PrepareContainerNode(params); err != nil { - return errors.Wrap(err, "setting up container node") + return fmt.Errorf("setting up container node: %w", err) } var waitForPreload sync.WaitGroup @@ -209,11 +208,11 @@ func (d *Driver) Create() error { } if err := oci.CreateContainerNode(params); err != nil { - return errors.Wrap(err, "create kic node") + return fmt.Errorf("create kic node: %w", err) } if err := d.prepareSSH(); err != nil { - return errors.Wrap(err, "prepare kic ssh") + return fmt.Errorf("prepare kic ssh: %w", err) } return nil @@ -224,13 +223,13 @@ func (d *Driver) prepareSSH() error { keyPath := d.GetSSHKeyPath() klog.Infof("Creating ssh key for kic: %s...", keyPath) if err := ssh.GenerateSSHKey(keyPath); err != nil { - return errors.Wrap(err, "generate ssh key") + return fmt.Errorf("generate ssh key: %w", err) } cmder := command.NewKICRunner(d.NodeConfig.MachineName, d.NodeConfig.OCIBinary) f, err := assets.NewFileAsset(d.GetSSHKeyPath()+".pub", "/home/docker/.ssh/", "authorized_keys", "0644") if err != nil { - return errors.Wrap(err, "create pubkey assetfile ") + return fmt.Errorf("create pubkey assetfile : %w", err) } defer func() { if err := f.Close(); err != nil { @@ -239,7 +238,7 @@ func (d *Driver) prepareSSH() error { }() if err := cmder.Copy(f); err != nil { - return errors.Wrap(err, "copying pub key") + return fmt.Errorf("copying pub key: %w", err) } // Double-check that the container has not crashed so that we may give a better error message @@ -250,11 +249,11 @@ func (d *Driver) prepareSSH() error { if s != state.Running { excerpt := oci.LogContainerDebug(d.OCIBinary, d.MachineName) - return errors.Wrapf(oci.ErrExitedUnexpectedly, "container name %q state %s: log: %s", d.MachineName, s, excerpt) + return fmt.Errorf("container name %q state %s: log: %s: %w", d.MachineName, s, excerpt, oci.ErrExitedUnexpectedly) } if rr, err := cmder.RunCmd(exec.Command("chown", "docker:docker", "/home/docker/.ssh/authorized_keys")); err != nil { - return errors.Wrapf(err, "apply authorized_keys file ownership, output %s", rr.Output()) + return fmt.Errorf("apply authorized_keys file ownership, output %s: %w", rr.Output(), err) } if runtime.GOOS == "windows" { @@ -275,7 +274,7 @@ func (d *Driver) prepareSSH() error { icaclsCmdOut, icaclsCmdErr := icaclsCmd.CombinedOutput() if icaclsCmdErr != nil { - return errors.Wrap(icaclsCmdErr, fmt.Sprintf("unable to execute icacls to set permissions: %s", icaclsCmdOut)) + return fmt.Errorf("%s: %w", fmt.Sprintf("unable to execute icacls to set permissions: %s", icaclsCmdOut), icaclsCmdErr) } } } @@ -311,7 +310,7 @@ func (d *Driver) GetSSHHostname() (string, error) { func (d *Driver) GetSSHPort() (int, error) { p, err := oci.ForwardedPort(d.OCIBinary, d.MachineName, constants.SSHPort) if err != nil { - return p, errors.Wrap(err, "get ssh host-port") + return p, fmt.Errorf("get ssh host-port: %w", err) } return p, nil } @@ -360,7 +359,7 @@ func (d *Driver) Kill() error { cr := command.NewExecRunner(false) // using exec runner for interacting with daemon. if _, err := cr.RunCmd(oci.PrefixCmd(exec.Command(d.NodeConfig.OCIBinary, "kill", d.MachineName))); err != nil { - return errors.Wrapf(err, "killing %q", d.MachineName) + return fmt.Errorf("killing %q: %w", d.MachineName, err) } return nil } @@ -373,7 +372,7 @@ func (d *Driver) Remove() error { if err := oci.DeleteContainer(context.Background(), d.NodeConfig.OCIBinary, d.MachineName); err != nil { if strings.Contains(err.Error(), "is already in progress") { - return errors.Wrap(err, "stuck delete") + return fmt.Errorf("stuck delete: %w", err) } if strings.Contains(err.Error(), "No such container:") { return nil // nothing was found to delete. @@ -415,9 +414,9 @@ func (d *Driver) Start() error { if err := oci.StartContainer(d.NodeConfig.OCIBinary, d.MachineName); err != nil { oci.LogContainerDebug(d.OCIBinary, d.MachineName) if _, err := oci.DaemonInfo(d.OCIBinary); err != nil { - return errors.Wrapf(oci.ErrDaemonInfo, "debug daemon info %q", d.MachineName) + return fmt.Errorf("debug daemon info %q: %w", d.MachineName, oci.ErrDaemonInfo) } - return errors.Wrap(err, "start") + return fmt.Errorf("start: %w", err) } checkRunning := func() error { s, err := oci.ContainerStatus(d.NodeConfig.OCIBinary, d.MachineName) @@ -435,10 +434,10 @@ func (d *Driver) Start() error { excerpt := oci.LogContainerDebug(d.OCIBinary, d.MachineName) _, err := oci.DaemonInfo(d.OCIBinary) if err != nil { - return errors.Wrapf(oci.ErrDaemonInfo, "container name %q", d.MachineName) + return fmt.Errorf("container name %q: %w", d.MachineName, oci.ErrDaemonInfo) } - return errors.Wrapf(oci.ErrExitedUnexpectedly, "container name %q: log: %s", d.MachineName, excerpt) + return fmt.Errorf("container name %q: log: %s: %w", d.MachineName, excerpt, oci.ErrExitedUnexpectedly) } return nil } @@ -483,7 +482,7 @@ func (d *Driver) Stop() error { cmd := exec.Command(d.NodeConfig.OCIBinary, "stop", d.MachineName) if err := cmd.Run(); err != nil { - return errors.Wrapf(err, "stopping %s", d.MachineName) + return fmt.Errorf("stopping %s: %w", d.MachineName, err) } return nil } @@ -503,7 +502,7 @@ func killAPIServerProc(runner command.Runner) error { if err == nil { // this means we have a valid pid klog.Warningf("Found a kube-apiserver running with pid %d, will try to kill the proc", pid) if _, err = runner.RunCmd(exec.Command("pkill", "-9", fmt.Sprint(pid))); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } } } diff --git a/pkg/drivers/kic/oci/info.go b/pkg/drivers/kic/oci/info.go index 92a17f3d54..f86c3eb2ab 100644 --- a/pkg/drivers/kic/oci/info.go +++ b/pkg/drivers/kic/oci/info.go @@ -18,11 +18,11 @@ package oci import ( "encoding/json" + "fmt" "os/exec" "strings" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" ) @@ -256,11 +256,11 @@ func dockerSystemInfo() (dockerSysInfo, error) { rawJSON, err := dockerInfoGetter() if err != nil { klog.Warningf("docker info: %v", err) - return ds, errors.Wrap(err, "docker system info") + return ds, fmt.Errorf("docker system info: %w", err) } if err := json.Unmarshal([]byte(strings.TrimSpace(rawJSON)), &ds); err != nil { klog.Warningf("unmarshal docker info: %v", err) - return ds, errors.Wrapf(err, "unmarshal docker system info") + return ds, fmt.Errorf("unmarshal docker system info: %w", err) } klog.Infof("docker info: %+v", ds) @@ -278,12 +278,12 @@ func podmanSystemInfo() (podmanSysInfo, error) { rawJSON, err := podmanInfoGetter() if err != nil { klog.Warningf("podman info: %v", err) - return ps, errors.Wrap(err, "podman system info") + return ps, fmt.Errorf("podman system info: %w", err) } if err := json.Unmarshal([]byte(strings.TrimSpace(rawJSON)), &ps); err != nil { klog.Warningf("unmarshal podman info: %v", err) - return ps, errors.Wrapf(err, "unmarshal podman system info") + return ps, fmt.Errorf("unmarshal podman system info: %w", err) } klog.Infof("podman info: %+v", ps) return ps, nil diff --git a/pkg/drivers/kic/oci/network.go b/pkg/drivers/kic/oci/network.go index 8486fa6989..7bb51ce151 100644 --- a/pkg/drivers/kic/oci/network.go +++ b/pkg/drivers/kic/oci/network.go @@ -24,8 +24,9 @@ import ( "strconv" "strings" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/constants" @@ -70,7 +71,7 @@ func RoutableHostIPFromInside(ociBin string, clusterName string, containerName s return containerGatewayIP(Docker, containerName) } - return info.gateway, errors.Wrap(err, "network inspect") + return info.gateway, fmt.Errorf("network inspect: %w", err) } return info.gateway, nil } @@ -90,7 +91,7 @@ func digDNS(ociBin, containerName, dns string) (net.IP, error) { rr, err := runCmd(exec.Command(ociBin, "exec", "-t", containerName, "dig", "+short", dns)) ip := net.ParseIP(strings.TrimSpace(rr.Stdout.String())) if err != nil { - return ip, errors.Wrapf(err, "resolve dns to ip") + return ip, fmt.Errorf("resolve dns to ip: %w", err) } klog.Infof("got host ip for mount in container by digging dns: %s", ip.String()) @@ -101,7 +102,7 @@ func digDNS(ociBin, containerName, dns string) (net.IP, error) { func gatewayIP(ociBin, containerName string) (string, error) { rr, err := runCmd(exec.Command(ociBin, "container", "inspect", "--format", "{{.NetworkSettings.Gateway}}", containerName)) if err != nil { - return "", errors.Wrapf(err, "inspect gateway") + return "", fmt.Errorf("inspect gateway: %w", err) } if gatewayIP := strings.TrimSpace(rr.Stdout.String()); gatewayIP != "" { return gatewayIP, nil @@ -133,7 +134,7 @@ func networkGateway(ociBin, container, network string) (string, error) { `, network, network) rr, err := runCmd(exec.Command(ociBin, "container", "inspect", "--format", format, container)) if err != nil { - return "", errors.Wrapf(err, "inspect gateway") + return "", fmt.Errorf("inspect gateway: %w", err) } return strings.TrimSpace(rr.Stdout.String()), nil } @@ -142,7 +143,7 @@ func networkGateway(ociBin, container, network string) (string, error) { func containerGatewayIP(ociBin string, containerName string) (net.IP, error) { gatewayIP, err := gatewayIP(ociBin, containerName) if err != nil { - return nil, errors.Wrapf(err, "inspect gateway") + return nil, fmt.Errorf("inspect gateway: %w", err) } return net.ParseIP(gatewayIP), nil } @@ -160,7 +161,7 @@ func ForwardedPort(ociBin string, ociID string, contPort int) (int, error) { if ociBin == Podman { v, err = podmanVersion() if err != nil { - return 0, errors.Wrapf(err, "podman version") + return 0, fmt.Errorf("podman version: %w", err) } } @@ -168,7 +169,7 @@ func ForwardedPort(ociBin string, ociID string, contPort int) (int, error) { if ociBin == Podman && v.LT(semver.Version{Major: 2, Minor: 0, Patch: 1}) { rr, err = runCmd(exec.Command(ociBin, "container", "inspect", "-f", fmt.Sprintf("{{range .NetworkSettings.Ports}}{{if eq .ContainerPort %s}}{{.HostPort}}{{end}}{{end}}", fmt.Sprint(contPort)), ociID)) if err != nil { - return 0, errors.Wrapf(err, "get port %d for %q", contPort, ociID) + return 0, fmt.Errorf("get port %d for %q: %w", contPort, ociID, err) } } else { rr, err = runCmd(exec.Command(ociBin, "container", "inspect", "-f", fmt.Sprintf("'{{(index (index .NetworkSettings.Ports \"%d/tcp\") 0).HostPort}}'", contPort), ociID)) @@ -181,7 +182,7 @@ func ForwardedPort(ociBin string, ociID string, contPort int) (int, error) { if strings.Contains(rr.Output(), "error calling index: index of untyped nil") { return 0, ErrGetPortContainerNotRunning } - return 0, errors.Wrapf(err, "get port %d for %q", contPort, ociID) + return 0, fmt.Errorf("get port %d for %q: %w", contPort, ociID, err) } } @@ -190,7 +191,7 @@ func ForwardedPort(ociBin string, ociID string, contPort int) (int, error) { p, err := strconv.Atoi(o) if err != nil { - return p, errors.Wrapf(err, "convert host-port %q to number", p) + return p, fmt.Errorf("convert host-port %q to number: %w", p, err) } return p, nil @@ -210,7 +211,7 @@ func podmanContainerIP(ociBin string, name string) (string, string, error) { "-f", "{{.NetworkSettings.IPAddress}}", name)) if err != nil { - return "", "", errors.Wrapf(err, "podman inspect ip %s", name) + return "", "", fmt.Errorf("podman inspect ip %s: %w", name, err) } output := strings.TrimSpace(rr.Stdout.String()) if output == "" { // podman returns empty for 127.0.0.1 @@ -229,16 +230,16 @@ func dockerContainerIP(ociBin string, name string) (string, string, error) { // retrieve the IP address of the node using docker inspect lines, err := inspect(ociBin, name, "{{range .NetworkSettings.Networks}}{{.IPAddress}},{{.GlobalIPv6Address}}{{end}}") if err != nil { - return "", "", errors.Wrap(err, "inspecting NetworkSettings.Networks") + return "", "", fmt.Errorf("inspecting NetworkSettings.Networks: %w", err) } if len(lines) != 1 { - return "", "", errors.Errorf("IPs output should only be one line, got %d lines", len(lines)) + return "", "", fmt.Errorf("IPs output should only be one line, got %d lines", len(lines)) } ips := strings.Split(lines[0], ",") if len(ips) != 2 { - return "", "", errors.Errorf("container addresses should have 2 values, got %d values: %+v", len(ips), ips) + return "", "", fmt.Errorf("container addresses should have 2 values, got %d values: %+v", len(ips), ips) } return ips[0], ips[1], nil } diff --git a/pkg/drivers/kic/oci/network_create.go b/pkg/drivers/kic/oci/network_create.go index cd38dc785c..fb53632d26 100644 --- a/pkg/drivers/kic/oci/network_create.go +++ b/pkg/drivers/kic/oci/network_create.go @@ -26,8 +26,9 @@ import ( "regexp" "strings" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/network" @@ -227,7 +228,7 @@ func dockerNetworkInspect(name string) (netInfo, error) { _, info.subnet, err = net.ParseCIDR(vals.Subnet) if err != nil { - return info, errors.Wrapf(err, "parse subnet for %s", name) + return info, fmt.Errorf("parse subnet for %s: %w", name, err) } return info, nil @@ -236,7 +237,7 @@ func dockerNetworkInspect(name string) (netInfo, error) { var podmanInspectGetter = func(name string) (*RunResult, error) { v, err := podmanVersion() if err != nil { - return nil, errors.Wrapf(err, "podman version") + return nil, fmt.Errorf("podman version: %w", err) } format := `{{range .}}{{if eq .Driver "bridge"}}{{(index .Subnets 0).Subnet}},{{(index .Subnets 0).Gateway}}{{end}}{{end}}` if v.LT(semver.Version{Major: 4, Minor: 0, Patch: 0}) { @@ -273,7 +274,7 @@ func podmanNetworkInspect(name string) (netInfo, error) { _, info.subnet, err = net.ParseCIDR(vals[0]) if err != nil { - return info, errors.Wrapf(err, "parse subnet for %s", name) + return info, fmt.Errorf("parse subnet for %s: %w", name, err) } return info, nil @@ -337,7 +338,7 @@ func DeleteKICNetworksByLabel(ociBin string, label string) []error { var errs []error ns, err := networkNamesByLabel(ociBin, label) if err != nil { - return []error{errors.Wrap(err, "list all volume")} + return []error{fmt.Errorf("list all volume: %w", err)} } for _, n := range ns { err := RemoveNetwork(ociBin, n) diff --git a/pkg/drivers/kic/oci/oci.go b/pkg/drivers/kic/oci/oci.go index f14d17d690..d4121c6391 100644 --- a/pkg/drivers/kic/oci/oci.go +++ b/pkg/drivers/kic/oci/oci.go @@ -30,7 +30,6 @@ import ( "time" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/state" "k8s.io/klog/v2" @@ -59,7 +58,7 @@ func DeleteContainersByLabel(ociBin string, label string) []error { // only try to delete if docker/podman inspect returns // if it doesn't it means docker daemon is stuck and needs restart if err != nil { - deleteErrs = append(deleteErrs, errors.Wrapf(err, "delete container %s: %s daemon is stuck. please try again", c, ociBin)) + deleteErrs = append(deleteErrs, fmt.Errorf("delete container %s: %s daemon is stuck. please try again: %w", c, ociBin, err)) klog.Errorf("%s daemon seems to be stuck. please try restarting your %s :%v", ociBin, ociBin, err) continue } @@ -68,7 +67,7 @@ func DeleteContainersByLabel(ociBin string, label string) []error { } if _, err := runCmd(exec.Command(ociBin, "rm", "-f", "-v", c)); err != nil { - deleteErrs = append(deleteErrs, errors.Wrapf(err, "delete container %s: output %s", c, err)) + deleteErrs = append(deleteErrs, fmt.Errorf("delete container %s: output %s: %w", c, err, err)) } } @@ -89,7 +88,7 @@ func DeleteContainer(ctx context.Context, ociBin string, name string) error { } if _, err := runCmd(exec.CommandContext(ctx, ociBin, "rm", "-f", "-v", name)); err != nil { - return errors.Wrapf(err, "delete %s", name) + return fmt.Errorf("delete %s: %w", name, err) } return nil } @@ -98,11 +97,11 @@ func DeleteContainer(ctx context.Context, ociBin string, name string) error { // For the container runtime, it creates a volume which will be mounted into kic func PrepareContainerNode(p CreateParams) error { if err := createVolume(p.OCIBinary, p.Name, p.Name); err != nil { - return errors.Wrapf(err, "creating volume for %s container", p.Name) + return fmt.Errorf("creating volume for %s container: %w", p.Name, err) } klog.Infof("Successfully created a %s volume %s", p.OCIBinary, p.Name) if err := prepareVolumeSideCar(p.OCIBinary, p.Image, p.Name); err != nil { - return errors.Wrapf(err, "preparing volume for %s container", p.Name) + return fmt.Errorf("preparing volume for %s container: %w", p.Name, err) } klog.Infof("Successfully prepared a %s volume %s", p.OCIBinary, p.Name) return nil @@ -156,7 +155,7 @@ func CreateContainerNode(p CreateParams) error { //nolint to suppress cyclomatic } if err != nil { klog.Warningf("error getting daemon info: %v", err) - return errors.Wrap(err, "daemon info") + return fmt.Errorf("daemon info: %w", err) } } @@ -273,17 +272,17 @@ func CreateContainerNode(p CreateParams) error { //nolint to suppress cyclomatic } if err := createContainer(p.OCIBinary, p.Image, withRunArgs(runArgs...), withMounts(p.Mounts), withPortMappings(p.PortMappings)); err != nil { - return errors.Wrap(err, "create container") + return fmt.Errorf("create container: %w", err) } if err := retry.Expo(checkRunning(p), 15*time.Millisecond, 25*time.Second); err != nil { excerpt := LogContainerDebug(p.OCIBinary, p.Name) _, err := DaemonInfo(p.OCIBinary) if err != nil { - return errors.Wrapf(ErrDaemonInfo, "container name %q", p.Name) + return fmt.Errorf("container name %q: %w", p.Name, ErrDaemonInfo) } - return errors.Wrapf(ErrExitedUnexpectedly, "container name %q: log: %s", p.Name, excerpt) + return fmt.Errorf("container name %q: log: %s: %w", p.Name, excerpt, ErrExitedUnexpectedly) } return nil @@ -596,12 +595,12 @@ func resetEnv(key string) error { v := os.Getenv(constants.MinikubeExistingPrefix + key) if v == "" { if err := os.Unsetenv(key); err != nil { - return errors.Wrapf(err, "resetting %s env", key) + return fmt.Errorf("resetting %s env: %w", key, err) } return nil } if err := os.Setenv(key, v); err != nil { - return errors.Wrapf(err, "resetting %s env", key) + return fmt.Errorf("resetting %s env: %w", key, err) } return nil } @@ -647,7 +646,7 @@ func ContainerStatus(ociBin string, name string, warnSlow ...bool) (state.State, case "dead": return state.Error, nil default: - return state.None, errors.Wrapf(err, "unknown state %q", name) + return state.None, fmt.Errorf("unknown state %q: %w", name, err) } } @@ -671,10 +670,10 @@ func ShutDown(ociBin string, name string) error { klog.Infof("temporary error verifying shutdown: %v", err) } klog.Infof("temporary error: container %s status is %s but expect it to be exited", name, st) - return errors.Wrap(err, "couldn't verify container is exited. %v") + return fmt.Errorf("couldn't verify container is exited: %w", err) } if err := retry.Expo(stopped, time.Millisecond*500, time.Second*20); err != nil { - return errors.Wrap(err, "verify shutdown") + return fmt.Errorf("verify shutdown: %w", err) } klog.Infof("Successfully shutdown container %s", name) return nil @@ -743,7 +742,7 @@ func IsExternalDaemonHost(driver string) bool { func podmanVersion() (semver.Version, error) { rr, err := runCmd(exec.Command(Podman, "version", "--format", "{{.Version}}")) if err != nil { - return semver.Version{}, errors.Wrapf(err, "podman version") + return semver.Version{}, fmt.Errorf("podman version: %w", err) } output := strings.TrimSpace(rr.Stdout.String()) return semver.Make(output) diff --git a/pkg/drivers/kic/oci/volumes.go b/pkg/drivers/kic/oci/volumes.go index 30a451f622..c8fb2646a2 100644 --- a/pkg/drivers/kic/oci/volumes.go +++ b/pkg/drivers/kic/oci/volumes.go @@ -26,7 +26,7 @@ import ( "runtime" "strings" - "github.com/pkg/errors" + "errors" "k8s.io/klog/v2" ) @@ -101,7 +101,7 @@ func PruneAllVolumesByLabel(ctx context.Context, ociBin string, label string, wa klog.Infof("trying to prune all %s volumes with label %s", ociBin, label) cmd := exec.CommandContext(ctx, ociBin, "volume", "prune", "-f", "--filter", "label="+label) if _, err := runCmd(cmd, warnSlow...); err != nil { - deleteErrs = append(deleteErrs, errors.Wrapf(err, "prune volume by label %s", label)) + deleteErrs = append(deleteErrs, fmt.Errorf("prune volume by label %s: %w", label, err)) } return deleteErrs diff --git a/pkg/drivers/krunkit/krunkit.go b/pkg/drivers/krunkit/krunkit.go index d4d9945492..c4bb2986c5 100644 --- a/pkg/drivers/krunkit/krunkit.go +++ b/pkg/drivers/krunkit/krunkit.go @@ -32,7 +32,8 @@ import ( "syscall" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" "k8s.io/minikube/pkg/libmachine/mcnutils" @@ -282,7 +283,7 @@ func (d *Driver) setupIP(mac string) error { getIP := func() error { d.IPAddress, err = common.GetIPAddressByMACAddress(mac) if err != nil { - return errors.Wrap(err, "failed to get IP address") + return fmt.Errorf("failed to get IP address: %w", err) } return nil } @@ -301,7 +302,7 @@ func (d *Driver) setupIP(mac string) error { return nil } if !isBootpdError(err) { - return errors.Wrap(err, "IP address never found in dhcp leases file") + return fmt.Errorf("IP address never found in dhcp leases file: %w", err) } if unblockErr := firewall.UnblockBootpd(&d.CommandOptions); unblockErr != nil { klog.Errorf("failed unblocking bootpd from firewall: %v", unblockErr) @@ -332,11 +333,11 @@ func (d *Driver) Kill() error { func (d *Driver) Remove() error { s, err := d.GetState() if err != nil { - return errors.Wrap(err, "get state") + return fmt.Errorf("get state: %w", err) } if s == state.Running { if err := d.Kill(); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } } return nil diff --git a/pkg/drivers/kvm/domain.go b/pkg/drivers/kvm/domain.go index 804dd5c5d7..d428ae0532 100644 --- a/pkg/drivers/kvm/domain.go +++ b/pkg/drivers/kvm/domain.go @@ -23,7 +23,6 @@ import ( "fmt" "text/template" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/log" "libvirt.org/go/libvirt" ) @@ -71,7 +70,7 @@ func (d *Driver) defineDomain() (*libvirt.Domain, error) { tmpl := template.Must(template.New("domain").Parse(domainTmpl)) var domainXML bytes.Buffer if err := tmpl.Execute(&domainXML, d); err != nil { - return nil, errors.Wrap(err, "executing domain xml") + return nil, fmt.Errorf("executing domain xml: %w", err) } conn, err := getConnection(d.ConnectionURI) if err != nil { @@ -86,7 +85,7 @@ func (d *Driver) defineDomain() (*libvirt.Domain, error) { log.Infof("defining domain using XML: %v", domainXML.String()) dom, err := conn.DomainDefineXML(domainXML.String()) if err != nil { - return nil, errors.Wrapf(err, "error defining domain xml: %s", domainXML.String()) + return nil, fmt.Errorf("error defining domain xml: %s: %w", domainXML.String(), err) } // save MAC address diff --git a/pkg/drivers/kvm/kvm.go b/pkg/drivers/kvm/kvm.go index 1379c78be7..eb603c0321 100644 --- a/pkg/drivers/kvm/kvm.go +++ b/pkg/drivers/kvm/kvm.go @@ -25,7 +25,8 @@ import ( "syscall" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/drivers/common" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" @@ -39,12 +40,12 @@ import ( // more info https://github.com/docker/machine/blob/b170508bf44c3405e079e26d5fdffe35a64c6972/libmachine/provision/utils.go#L159_L175 func (d *Driver) GetURL() (string, error) { if err := d.PreCommandCheck(); err != nil { - return "", errors.Wrap(err, "prechecking") + return "", fmt.Errorf("prechecking: %w", err) } ip, err := d.GetIP() if err != nil { - return "", errors.Wrap(err, "getting domain IP") + return "", fmt.Errorf("getting domain IP: %w", err) } if ip == "" { @@ -68,7 +69,7 @@ func (d *Driver) PreCommandCheck() error { libVersion, err := conn.GetLibVersion() if err != nil { - return errors.Wrap(err, "getting libvirt version") + return fmt.Errorf("getting libvirt version: %w", err) } log.Debugf("using libvirt version %d", libVersion) @@ -80,7 +81,7 @@ func (d *Driver) PreCommandCheck() error { func (d *Driver) GetState() (state.State, error) { dom, conn, err := d.getDomain() if err != nil { - return state.None, errors.Wrap(err, "getting domain") + return state.None, fmt.Errorf("getting domain: %w", err) } defer func() { if err := closeDomain(dom, conn); err != nil { @@ -90,7 +91,7 @@ func (d *Driver) GetState() (state.State, error) { lvs, _, err := dom.GetState() // state, reason, error if err != nil { - return state.None, errors.Wrap(err, "getting domain state") + return state.None, fmt.Errorf("getting domain state: %w", err) } return machineState(lvs), nil @@ -133,7 +134,7 @@ func machineState(lvs libvirt.DomainState) state.State { func (d *Driver) GetIP() (string, error) { s, err := d.GetState() if err != nil { - return "", errors.Wrap(err, "getting domain state") + return "", fmt.Errorf("getting domain state: %w", err) } if s != state.Running { @@ -167,7 +168,7 @@ func (d *Driver) DriverName() string { func (d *Driver) Kill() error { s, err := d.GetState() if err != nil { - return errors.Wrap(err, "getting domain state") + return fmt.Errorf("getting domain state: %w", err) } if s == state.Stopped { @@ -178,7 +179,7 @@ func (d *Driver) Kill() error { dom, conn, err := d.getDomain() if err != nil { - return errors.Wrap(err, "getting domain") + return fmt.Errorf("getting domain: %w", err) } defer func() { if err := closeDomain(dom, conn); err != nil { @@ -210,13 +211,13 @@ func (d *Driver) Start() error { // this call ensures that all networks are active log.Info("ensuring networks are active...") if err := d.ensureNetwork(); err != nil { - return errors.Wrap(err, "ensuring active networks") + return fmt.Errorf("ensuring active networks: %w", err) } log.Info("getting domain XML...") dom, conn, err := d.getDomain() if err != nil { - return errors.Wrap(err, "getting domain XML") + return fmt.Errorf("getting domain XML: %w", err) } defer func() { if err := closeDomain(dom, conn); err != nil { @@ -232,23 +233,23 @@ func (d *Driver) Start() error { } if err := dom.Create(); err != nil { - return errors.Wrap(err, "creating domain") + return fmt.Errorf("creating domain: %w", err) } log.Info("waiting for domain to start...") if err := d.waitForDomainState(state.Running, 30*time.Second); err != nil { - return errors.Wrap(err, "waiting for domain to start") + return fmt.Errorf("waiting for domain to start: %w", err) } log.Info("domain is now running") log.Info("waiting for IP...") if err := d.waitForStaticIP(conn, 90*time.Second); err != nil { - return errors.Wrap(err, "waiting for IP") + return fmt.Errorf("waiting for IP: %w", err) } log.Info("waiting for SSH...") if err := drivers.WaitForSSH(d); err != nil { - return errors.Wrap(err, "waiting for SSH") + return fmt.Errorf("waiting for SSH: %w", err) } return nil @@ -280,7 +281,7 @@ func (d *Driver) waitForStaticIP(conn *libvirt.Connect, maxTime time.Duration) e query := func() error { sip, err := ipFromAPI(conn, d.MachineName, d.PrivateNetwork) if err != nil { - return errors.Wrap(err, "getting domain IP, will retry") + return fmt.Errorf("getting domain IP, will retry: %w", err) } if sip == "" { @@ -312,14 +313,14 @@ func (d *Driver) Create() error { log.Info("creating network...") if err := d.createNetwork(); err != nil { - return errors.Wrap(err, "creating network") + return fmt.Errorf("creating network: %w", err) } if d.GPU { log.Info("getting devices XML...") xml, err := getDevicesXML() if err != nil { - return errors.Wrap(err, "getting devices XML") + return fmt.Errorf("getting devices XML: %w", err) } d.DevicesXML = xml } @@ -327,7 +328,7 @@ func (d *Driver) Create() error { if d.NUMANodeCount > 1 { numaXML, err := numaXML(d.CPU, d.Memory, d.NUMANodeCount) if err != nil { - return errors.Wrap(err, "creating NUMA XML") + return fmt.Errorf("creating NUMA XML: %w", err) } d.NUMANodeXML = numaXML } @@ -336,12 +337,12 @@ func (d *Driver) Create() error { log.Infof("setting up store path in %s ...", store) // 0755 because it must be accessible by libvirt/qemu across a variety of configs if err := os.MkdirAll(store, 0755); err != nil { - return errors.Wrap(err, "creating store") + return fmt.Errorf("creating store: %w", err) } log.Infof("building disk image from %s", d.Boot2DockerURL) if err := common.MakeDiskImage(d.BaseDriver, d.Boot2DockerURL, d.DiskSize); err != nil { - return errors.Wrap(err, "creating disk") + return fmt.Errorf("creating disk: %w", err) } if d.ExtraDisks > 20 { @@ -353,13 +354,13 @@ func (d *Driver) Create() error { for i := 0; i < d.ExtraDisks; i++ { diskpath := common.ExtraDiskPath(d.BaseDriver, i) if err := common.CreateRawDisk(diskpath, d.DiskSize); err != nil { - return errors.Wrap(err, "creating extra disks") + return fmt.Errorf("creating extra disks: %w", err) } // Starting the logical names for the extra disks from hdd as the cdrom device is set to hdc. // TODO: Enhance the domain template to use variable for the logical name of the main disk and the cdrom disk. extraDisksXML, err := getExtraDiskXML(diskpath, fmt.Sprintf("hd%v", string(rune('d'+i)))) if err != nil { - return errors.Wrap(err, "creating extraDisk XML") + return fmt.Errorf("creating extraDisk XML: %w", err) } d.ExtraDisksXML = append(d.ExtraDisksXML, extraDisksXML) } @@ -371,7 +372,7 @@ func (d *Driver) Create() error { log.Info("defining domain...") dom, err := d.defineDomain() if err != nil { - return errors.Wrap(err, "defining domain") + return fmt.Errorf("defining domain: %w", err) } defer func() { if dom == nil { @@ -382,7 +383,7 @@ func (d *Driver) Create() error { }() if err := d.Start(); err != nil { - return errors.Wrap(err, "starting domain") + return fmt.Errorf("starting domain: %w", err) } log.Infof("domain creation complete") @@ -513,11 +514,11 @@ func (d *Driver) Remove() error { log.Infof("domain %s exists, removing...", d.MachineName) if err := d.destroyRunningDomain(dom); err != nil { - return errors.Wrap(err, "destroying running domain") + return fmt.Errorf("destroying running domain: %w", err) } if err := d.undefineDomain(conn, dom); err != nil { - return errors.Wrap(err, "undefining domain") + return fmt.Errorf("undefining domain: %w", err) } log.Info("removing static IP address...") @@ -535,7 +536,7 @@ func (d *Driver) Remove() error { func (d *Driver) destroyRunningDomain(dom *libvirt.Domain) error { lvs, _, err := dom.GetState() if err != nil { - return errors.Wrap(err, "getting domain state") + return fmt.Errorf("getting domain state: %w", err) } // if the domain is not running, we don't destroy it @@ -550,7 +551,7 @@ func (d *Driver) destroyRunningDomain(dom *libvirt.Domain) error { func (d *Driver) undefineDomain(conn *libvirt.Connect, dom *libvirt.Domain) error { definedDomains, err := conn.ListDefinedDomains() if err != nil { - return errors.Wrap(err, "listing domains") + return fmt.Errorf("listing domains: %w", err) } var found bool diff --git a/pkg/drivers/kvm/network.go b/pkg/drivers/kvm/network.go index de6bfad53d..fed56055ac 100644 --- a/pkg/drivers/kvm/network.go +++ b/pkg/drivers/kvm/network.go @@ -26,7 +26,6 @@ import ( "text/template" "time" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/log" "k8s.io/minikube/pkg/network" "k8s.io/minikube/pkg/util/retry" @@ -97,24 +96,24 @@ func setupNetwork(conn *libvirt.Connect, name string) error { // always ensure autostart is set on the network autostart, err := n.GetAutostart() if err != nil { - return errors.Wrapf(err, "checking network %s autostart", name) + return fmt.Errorf("checking network %s autostart: %w", name, err) } if !autostart { if err := n.SetAutostart(true); err != nil { - return errors.Wrapf(err, "setting autostart for network %s", name) + return fmt.Errorf("setting autostart for network %s: %w", name, err) } } // always ensure the network is started (active) active, err := n.IsActive() if err != nil { - return errors.Wrapf(err, "checking network status for %s", name) + return fmt.Errorf("checking network status for %s: %w", name, err) } if !active { log.Debugf("network %s is not active, trying to start it...", name) if err := n.Create(); err != nil { - return errors.Wrapf(err, "starting network %s", name) + return fmt.Errorf("starting network %s: %w", name, err) } } return nil @@ -148,11 +147,11 @@ func (d *Driver) ensureNetwork() error { if err := setupNetwork(conn, d.PrivateNetwork); err != nil { log.Debugf("Network %s is inoperable, will try to recreate it: %v", d.PrivateNetwork, err) if err := d.deleteNetwork(); err != nil { - return errors.Wrapf(err, "deleting inoperable network %s", d.PrivateNetwork) + return fmt.Errorf("deleting inoperable network %s: %w", d.PrivateNetwork, err) } log.Debugf("Successfully deleted %s network", d.PrivateNetwork) if err := d.createNetwork(); err != nil { - return errors.Wrapf(err, "recreating inoperable network %s", d.PrivateNetwork) + return fmt.Errorf("recreating inoperable network %s: %w", d.PrivateNetwork, err) } log.Debugf("Successfully recreated %s network", d.PrivateNetwork) if err := setupNetwork(conn, d.PrivateNetwork); err != nil { @@ -293,7 +292,7 @@ func (d *Driver) deleteNetwork() error { log.Warnf("Network %s does not exist. Skipping deletion", d.PrivateNetwork) return nil } - return errors.Wrapf(err, "failed looking up network %s", d.PrivateNetwork) + return fmt.Errorf("failed looking up network %s: %w", d.PrivateNetwork, err) } defer func() { if libvirtNet == nil { @@ -328,7 +327,7 @@ func (d *Driver) deleteNetwork() error { return libvirtNet.Undefine() } if err := retry.Local(deleteFunc, 10*time.Second); err != nil { - return errors.Wrap(err, "deleting network") + return fmt.Errorf("deleting network: %w", err) } log.Debugf("Network %s deleted", d.PrivateNetwork) @@ -356,7 +355,7 @@ func (d *Driver) checkDomains(conn *libvirt.Connect) error { log.Debug("Trying to list all domains...") doms, err := conn.ListAllDomains(0) if err != nil { - return errors.Wrap(err, "list all domains") + return fmt.Errorf("list all domains: %w", err) } log.Debugf("Listed all domains: total of %d domains", len(doms)) @@ -370,7 +369,7 @@ func (d *Driver) checkDomains(conn *libvirt.Connect) error { log.Debug("Trying to get name of domain...") name, err := dom.GetName() if err != nil { - return errors.Wrap(err, "failed to get name of a domain") + return fmt.Errorf("failed to get name of a domain: %w", err) } log.Debugf("Got domain name: %s", name) @@ -386,14 +385,14 @@ func (d *Driver) checkDomains(conn *libvirt.Connect) error { log.Debugf("Getting XML for domain %s...", name) xmlString, err := dom.GetXMLDesc(libvirt.DOMAIN_XML_INACTIVE) if err != nil { - return errors.Wrapf(err, "failed to get XML of domain '%s'", name) + return fmt.Errorf("failed to get XML of domain '%s': %w", name, err) } log.Debugf("Got XML for domain %s", name) v := result{} err = xml.Unmarshal([]byte(xmlString), &v) if err != nil { - return errors.Wrapf(err, "failed to unmarshal XML of domain '%s", name) + return fmt.Errorf("failed to unmarshal XML of domain '%s: %w", name, err) } log.Debugf("Unmarshaled XML for domain %s: %#v", name, v) diff --git a/pkg/drivers/none/none.go b/pkg/drivers/none/none.go index b9287ef84d..4eb256d5f6 100644 --- a/pkg/drivers/none/none.go +++ b/pkg/drivers/none/none.go @@ -21,7 +21,6 @@ import ( "fmt" "os/exec" - "github.com/pkg/errors" knet "k8s.io/apimachinery/pkg/util/net" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/common" @@ -157,25 +156,25 @@ func (d *Driver) Kill() error { // First try to gracefully stop containers containers, err := d.runtime.ListContainers(cruntime.ListContainersOptions{}) if err != nil { - return errors.Wrap(err, "containers") + return fmt.Errorf("containers: %w", err) } if len(containers) == 0 { return nil } // Try to be graceful before sending SIGKILL everywhere. if err := d.runtime.StopContainers(containers); err != nil { - return errors.Wrap(err, "stop") + return fmt.Errorf("stop: %w", err) } containers, err = d.runtime.ListContainers(cruntime.ListContainersOptions{}) if err != nil { - return errors.Wrap(err, "containers") + return fmt.Errorf("containers: %w", err) } if len(containers) == 0 { return nil } if err := d.runtime.KillContainers(containers); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } return nil } @@ -183,7 +182,7 @@ func (d *Driver) Kill() error { // Remove a host, including any data which may have been written by it. func (d *Driver) Remove() error { if err := d.Kill(); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } klog.Infof("Removing: %s", cleanupPaths) args := append([]string{"rm", "-rf"}, cleanupPaths...) @@ -223,22 +222,22 @@ func (d *Driver) Stop() error { // Stop running containers running, err := d.runtime.ListContainers(cruntime.ListContainersOptions{State: cruntime.Running}) if err != nil { - return errors.Wrap(err, "list running containers") + return fmt.Errorf("list running containers: %w", err) } if len(running) > 0 { if err := d.runtime.StopContainers(running); err != nil { - return errors.Wrap(err, "stop running containers") + return fmt.Errorf("stop running containers: %w", err) } } // Stop paused containers paused, err := d.runtime.ListContainers(cruntime.ListContainersOptions{State: cruntime.Paused}) if err != nil { - return errors.Wrap(err, "list paused containers") + return fmt.Errorf("list paused containers: %w", err) } if len(paused) > 0 { if err := d.runtime.StopContainers(paused); err != nil { - return errors.Wrap(err, "stop paused containers") + return fmt.Errorf("stop paused containers: %w", err) } } klog.Infof("none driver is stopped!") diff --git a/pkg/drivers/qemu/qemu.go b/pkg/drivers/qemu/qemu.go index 813a1d4571..1e4464b377 100644 --- a/pkg/drivers/qemu/qemu.go +++ b/pkg/drivers/qemu/qemu.go @@ -32,7 +32,8 @@ import ( "syscall" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" "k8s.io/minikube/pkg/libmachine/mcnutils" @@ -313,12 +314,12 @@ func parsePortRange(rawPortRange string) (int, int, error) { minPort, err := strconv.Atoi(portRange[0]) if err != nil { - return 0, 0, errors.Wrap(err, "invalid min port range") + return 0, 0, fmt.Errorf("invalid min port range: %w", err) } maxPort, err := strconv.Atoi(portRange[1]) if err != nil { - return 0, 0, errors.Wrap(err, "invalid max port range") + return 0, 0, fmt.Errorf("invalid max port range: %w", err) } if maxPort < minPort { @@ -515,7 +516,7 @@ func (d *Driver) Start() error { getIP := func() error { d.IPAddress, err = common.GetIPAddressByMACAddress(d.MACAddress) if err != nil { - return errors.Wrap(err, "failed to get IP address") + return fmt.Errorf("failed to get IP address: %w", err) } return nil } @@ -538,7 +539,7 @@ func (d *Driver) Start() error { break } if !isBootpdError(err) { - return errors.Wrap(err, "IP address never found in dhcp leases file") + return fmt.Errorf("IP address never found in dhcp leases file: %w", err) } if unblockErr := firewall.UnblockBootpd(&d.CommandOptions); unblockErr != nil { klog.Errorf("failed unblocking bootpd from firewall: %v", unblockErr) @@ -616,16 +617,16 @@ func (d *Driver) Stop() error { func (d *Driver) Remove() error { s, err := d.GetState() if err != nil { - return errors.Wrap(err, "get state") + return fmt.Errorf("get state: %w", err) } if s == state.Running { if err := d.Kill(); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } } if s != state.Stopped { if _, err := d.RunQMPCommand("quit"); err != nil { - return errors.Wrap(err, "quit") + return fmt.Errorf("quit: %w", err) } } return nil @@ -785,7 +786,7 @@ func (d *Driver) RunQMPCommand(command string) (map[string]interface{}, error) { // connect to monitor conn, err := net.Dial("unix", d.monitorPath()) if err != nil { - return nil, errors.Wrap(err, "connect") + return nil, fmt.Errorf("connect: %w", err) } defer conn.Close() @@ -793,7 +794,7 @@ func (d *Driver) RunQMPCommand(command string) (map[string]interface{}, error) { var buf [1024]byte nr, err := conn.Read(buf[:]) if err != nil { - return nil, errors.Wrap(err, "read initial resp") + return nil, fmt.Errorf("read initial resp: %w", err) } type qmpInitialResponse struct { QMP struct { @@ -811,7 +812,7 @@ func (d *Driver) RunQMPCommand(command string) (map[string]interface{}, error) { var initialResponse qmpInitialResponse if err := json.Unmarshal(buf[:nr], &initialResponse); err != nil { - return nil, errors.Wrap(err, "unmarshal initial resp") + return nil, fmt.Errorf("unmarshal initial resp: %w", err) } // run 'qmp_capabilities' to switch to command mode @@ -821,21 +822,21 @@ func (d *Driver) RunQMPCommand(command string) (map[string]interface{}, error) { } jsonCommand, err := json.Marshal(qmpCommand{Command: "qmp_capabilities"}) if err != nil { - return nil, errors.Wrap(err, "marshal qmp_capabilities") + return nil, fmt.Errorf("marshal qmp_capabilities: %w", err) } if _, err := conn.Write(jsonCommand); err != nil { - return nil, errors.Wrap(err, "write qmp_capabilities") + return nil, fmt.Errorf("write qmp_capabilities: %w", err) } nr, err = conn.Read(buf[:]) if err != nil { - return nil, errors.Wrap(err, "read qmp_capabilities resp") + return nil, fmt.Errorf("read qmp_capabilities resp: %w", err) } type qmpResponse struct { Return map[string]interface{} `json:"return"` } var response qmpResponse if err := json.Unmarshal(buf[:nr], &response); err != nil { - return nil, errors.Wrap(err, "unmarshal qmp_capabilities resp") + return nil, fmt.Errorf("unmarshal qmp_capabilities resp: %w", err) } // expecting empty response if len(response.Return) != 0 { @@ -845,21 +846,21 @@ func (d *Driver) RunQMPCommand(command string) (map[string]interface{}, error) { // { "execute": command } jsonCommand, err = json.Marshal(qmpCommand{Command: command}) if err != nil { - return nil, errors.Wrap(err, "marshal command") + return nil, fmt.Errorf("marshal command: %w", err) } if _, err := conn.Write(jsonCommand); err != nil { - return nil, errors.Wrap(err, "write command") + return nil, fmt.Errorf("write command: %w", err) } nr, err = conn.Read(buf[:]) if err != nil { - return nil, errors.Wrap(err, "read command resp") + return nil, fmt.Errorf("read command resp: %w", err) } // Sometimes QEMU returns two JSON objects with the first object being the command response // and the second object being an event log (unimportant) firstRespObj := strings.Split(string(buf[:nr]), "\n")[0] if err := json.Unmarshal([]byte(firstRespObj), &response); err != nil { - return nil, errors.Wrap(err, "unmarshal command resp") + return nil, fmt.Errorf("unmarshal command resp: %w", err) } if strings.HasPrefix(command, "query-") { return response.Return, nil diff --git a/pkg/drivers/ssh/ssh.go b/pkg/drivers/ssh/ssh.go index e6394f8e5a..363f276657 100644 --- a/pkg/drivers/ssh/ssh.go +++ b/pkg/drivers/ssh/ssh.go @@ -28,7 +28,6 @@ import ( "golang.org/x/crypto/ssh" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/common" "k8s.io/minikube/pkg/libmachine/drivers" @@ -117,7 +116,7 @@ func (d *Driver) PreCreateCheck() error { _, err = ssh.ParsePrivateKey(key) if err != nil { - return errors.Wrapf(err, "SSH key does not parse: %q", d.SSHKey) + return fmt.Errorf("SSH key does not parse: %q: %w", d.SSHKey, err) } } @@ -144,11 +143,11 @@ func (d *Driver) Create() error { if d.runtime.Name() == "Docker" { groups, err := d.exec.RunCmd(exec.Command("groups", d.GetSSHUsername())) if err != nil { - return errors.Wrap(err, "groups") + return fmt.Errorf("groups: %w", err) } if !strings.Contains(groups.Stdout.String(), "docker") { if _, err := d.exec.RunCmd(exec.Command("sudo", "usermod", "-aG", "docker", d.GetSSHUsername())); err != nil { - return errors.Wrap(err, "usermod") + return fmt.Errorf("usermod: %w", err) } } } @@ -199,11 +198,11 @@ func (d *Driver) Stop() error { } containers, err := d.runtime.ListContainers(cruntime.ListContainersOptions{}) if err != nil { - return errors.Wrap(err, "containers") + return fmt.Errorf("containers: %w", err) } if len(containers) > 0 { if err := d.runtime.StopContainers(containers); err != nil { - return errors.Wrap(err, "stop containers") + return fmt.Errorf("stop containers: %w", err) } } klog.Infof("ssh driver is stopped!") @@ -224,25 +223,25 @@ func (d *Driver) Kill() error { // First try to gracefully stop containers containers, err := d.runtime.ListContainers(cruntime.ListContainersOptions{}) if err != nil { - return errors.Wrap(err, "containers") + return fmt.Errorf("containers: %w", err) } if len(containers) == 0 { return nil } // Try to be graceful before sending SIGKILL everywhere. if err := d.runtime.StopContainers(containers); err != nil { - return errors.Wrap(err, "stop") + return fmt.Errorf("stop: %w", err) } containers, err = d.runtime.ListContainers(cruntime.ListContainersOptions{}) if err != nil { - return errors.Wrap(err, "containers") + return fmt.Errorf("containers: %w", err) } if len(containers) == 0 { return nil } if err := d.runtime.KillContainers(containers); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } return nil } diff --git a/pkg/drivers/vfkit/vfkit.go b/pkg/drivers/vfkit/vfkit.go index ba72b3bc00..bbb49292b7 100644 --- a/pkg/drivers/vfkit/vfkit.go +++ b/pkg/drivers/vfkit/vfkit.go @@ -34,7 +34,8 @@ import ( "syscall" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" "k8s.io/minikube/pkg/libmachine/mcnutils" @@ -420,7 +421,7 @@ func (d *Driver) setupIP(mac string) error { getIP := func() error { d.IPAddress, err = common.GetIPAddressByMACAddress(mac) if err != nil { - return errors.Wrap(err, "failed to get IP address") + return fmt.Errorf("failed to get IP address: %w", err) } return nil } @@ -443,7 +444,7 @@ func (d *Driver) setupIP(mac string) error { return nil } if !isBootpdError(err) { - return errors.Wrap(err, "IP address never found in dhcp leases file") + return fmt.Errorf("IP address never found in dhcp leases file: %w", err) } if unblockErr := firewall.UnblockBootpd(&d.CommandOptions); unblockErr != nil { klog.Errorf("failed unblocking bootpd from firewall: %v", unblockErr) @@ -508,11 +509,11 @@ func (d *Driver) Stop() error { func (d *Driver) Remove() error { s, err := d.GetState() if err != nil { - return errors.Wrap(err, "get state") + return fmt.Errorf("get state: %w", err) } if s == state.Running { if err := d.Kill(); err != nil { - return errors.Wrap(err, "kill") + return fmt.Errorf("kill: %w", err) } } return nil diff --git a/pkg/drivers/vmware/driver.go b/pkg/drivers/vmware/driver.go index 8175c4f13e..6e752a5e13 100644 --- a/pkg/drivers/vmware/driver.go +++ b/pkg/drivers/vmware/driver.go @@ -34,7 +34,7 @@ import ( "text/template" "time" - "github.com/pkg/errors" + "errors" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/log" diff --git a/pkg/generate/docs.go b/pkg/generate/docs.go index bdfac319a7..6cfc9fd460 100644 --- a/pkg/generate/docs.go +++ b/pkg/generate/docs.go @@ -24,7 +24,6 @@ import ( "path/filepath" "time" - "github.com/pkg/errors" "github.com/spf13/cobra" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/out" @@ -40,15 +39,15 @@ func Docs(root *cobra.Command, path string, testPath string, codePath string) er } contents, err := DocForCommand(c) if err != nil { - return errors.Wrapf(err, "generating doc for %s", c.Name()) + return fmt.Errorf("generating doc for %s: %w", c.Name(), err) } if err := saveDocForCommand(c, []byte(contents), path); err != nil { - return errors.Wrapf(err, "saving doc for %s", c.Name()) + return fmt.Errorf("saving doc for %s: %w", c.Name(), err) } } err := TestDocs(testPath, "test/integration") if err != nil { - return errors.Wrap(err, "failed to generate test docs") + return fmt.Errorf("failed to generate test docs: %w", err) } return ErrorCodes(codePath, []string{"pkg/minikube/reason/reason.go", "pkg/minikube/reason/exitcodes.go"}) @@ -58,16 +57,16 @@ func Docs(root *cobra.Command, path string, testPath string, codePath string) er func DocForCommand(command *cobra.Command) (string, error) { buf := bytes.NewBuffer([]byte{}) if err := generateTitle(command, buf); err != nil { - return "", errors.Wrap(err, "generating title") + return "", fmt.Errorf("generating title: %w", err) } if err := rewriteLogFile(); err != nil { - return "", errors.Wrap(err, "rewriting log_file") + return "", fmt.Errorf("rewriting log_file: %w", err) } if err := rewriteFlags(command); err != nil { - return "", errors.Wrap(err, "rewriting flags") + return "", fmt.Errorf("rewriting flags: %w", err) } if err := writeSubcommands(command, buf); err != nil { - return "", errors.Wrap(err, "writing subcommands") + return "", fmt.Errorf("writing subcommands: %w", err) } return buf.String(), nil } @@ -139,7 +138,7 @@ func printOptions(buf *bytes.Buffer, cmd *cobra.Command) error { // writeSubcommands recursively appends all subcommands to the doc func writeSubcommands(command *cobra.Command, w io.Writer) error { if err := GenMarkdown(command, w); err != nil { - return errors.Wrapf(err, "getting markdown custom") + return fmt.Errorf("getting markdown custom: %w", err) } if !command.HasSubCommands() { return nil diff --git a/pkg/generate/errorcodes.go b/pkg/generate/errorcodes.go index 145d92d47d..e61c2758ae 100644 --- a/pkg/generate/errorcodes.go +++ b/pkg/generate/errorcodes.go @@ -26,7 +26,6 @@ import ( "strings" "time" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/out" ) @@ -44,11 +43,11 @@ func ErrorCodes(docPath string, pathsToCheck []string) error { for _, pathToCheck := range pathsToCheck { r, err := os.ReadFile(pathToCheck) if err != nil { - return errors.Wrap(err, fmt.Sprintf("error reading file %s", pathToCheck)) + return fmt.Errorf("%s: %w", fmt.Sprintf("error reading file %s", pathToCheck), err) } file, err := parser.ParseFile(fset, "", r, parser.ParseComments) if err != nil { - return errors.Wrap(err, fmt.Sprintf("error parsing file %s", pathToCheck)) + return fmt.Errorf("%s: %w", fmt.Sprintf("error parsing file %s", pathToCheck), err) } if strings.Contains(pathToCheck, "exitcodes.go") { diff --git a/pkg/generate/testdocs.go b/pkg/generate/testdocs.go index 75e3317626..b711874fe7 100644 --- a/pkg/generate/testdocs.go +++ b/pkg/generate/testdocs.go @@ -29,7 +29,6 @@ import ( "strings" "time" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/out" ) @@ -50,11 +49,11 @@ func TestDocs(docPath string, pathToCheck string) error { fset := token.NewFileSet() r, e := os.ReadFile(path) if e != nil { - return errors.Wrap(e, fmt.Sprintf("error reading file %s", path)) + return fmt.Errorf("%s: %w", fmt.Sprintf("error reading file %s", path), e) } file, e := parser.ParseFile(fset, "", r, parser.ParseComments) if e != nil { - return errors.Wrap(e, fmt.Sprintf("error parsing file %s", path)) + return fmt.Errorf("%s: %w", fmt.Sprintf("error parsing file %s", path), e) } ast.Inspect(file, func(x ast.Node) bool { diff --git a/pkg/gvisor/disable.go b/pkg/gvisor/disable.go index 56a9a7fd83..6c93e84451 100644 --- a/pkg/gvisor/disable.go +++ b/pkg/gvisor/disable.go @@ -17,11 +17,11 @@ limitations under the License. package gvisor import ( + "fmt" "log" "os" "path/filepath" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/mcnutils" ) @@ -29,15 +29,15 @@ import ( func Disable() error { log.Print("Disabling gvisor...") if err := os.Remove(filepath.Join(nodeDir, containerdConfigPath)); err != nil { - return errors.Wrapf(err, "removing %s", containerdConfigPath) + return fmt.Errorf("removing %s: %w", containerdConfigPath, err) } log.Printf("Restoring default config.toml at %s", containerdConfigPath) if err := mcnutils.CopyFile(filepath.Join(nodeDir, containerdConfigBackupPath), filepath.Join(nodeDir, containerdConfigPath)); err != nil { - return errors.Wrap(err, "reverting back to default config.toml") + return fmt.Errorf("reverting back to default config.toml: %w", err) } // restart containerd if err := restartContainerd(); err != nil { - return errors.Wrap(err, "restarting containerd") + return fmt.Errorf("restarting containerd: %w", err) } log.Print("Successfully disabled gvisor") return nil diff --git a/pkg/gvisor/enable.go b/pkg/gvisor/enable.go index bc6a563396..d2a0009d31 100644 --- a/pkg/gvisor/enable.go +++ b/pkg/gvisor/enable.go @@ -28,7 +28,6 @@ import ( "runtime" "syscall" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/mcnutils" ) @@ -67,16 +66,16 @@ func releaseURL() string { // 4. restarts containerd func Enable() error { if err := makeGvisorDirs(); err != nil { - return errors.Wrap(err, "creating directories on node") + return fmt.Errorf("creating directories on node: %w", err) } if err := downloadBinaries(); err != nil { - return errors.Wrap(err, "downloading binaries") + return fmt.Errorf("downloading binaries: %w", err) } if err := configure(); err != nil { - return errors.Wrap(err, "copying config files") + return fmt.Errorf("copying config files: %w", err) } if err := restartContainerd(); err != nil { - return errors.Wrap(err, "restarting containerd") + return fmt.Errorf("restarting containerd: %w", err) } // When pod is terminated, disable gvisor and exit c := make(chan os.Signal, 1) @@ -99,13 +98,13 @@ func makeGvisorDirs() error { // Make /run/containerd/runsc to hold logs fp := filepath.Join(nodeDir, "run/containerd/runsc") if err := os.MkdirAll(fp, 0755); err != nil { - return errors.Wrap(err, "creating runsc dir") + return fmt.Errorf("creating runsc dir: %w", err) } // Make /tmp/runsc to also hold logs fp = filepath.Join(nodeDir, "tmp/runsc") if err := os.MkdirAll(fp, 0755); err != nil { - return errors.Wrap(err, "creating runsc logs dir") + return fmt.Errorf("creating runsc logs dir: %w", err) } return nil @@ -113,10 +112,10 @@ func makeGvisorDirs() error { func downloadBinaries() error { if err := runsc(); err != nil { - return errors.Wrap(err, "downloading runsc") + return fmt.Errorf("downloading runsc: %w", err) } if err := gvisorContainerdShim(); err != nil { - return errors.Wrap(err, "downloading gvisor-containerd-shim") + return fmt.Errorf("downloading gvisor-containerd-shim: %w", err) } return nil } @@ -139,7 +138,7 @@ func downloadFileToDest(url, dest string) error { client := &http.Client{} req, err := http.NewRequest("GET", url, nil) if err != nil { - return errors.Wrapf(err, "creating request for %s", url) + return fmt.Errorf("creating request for %s: %w", url, err) } req.Header.Set("User-Agent", "minikube") resp, err := client.Do(req) @@ -149,19 +148,19 @@ func downloadFileToDest(url, dest string) error { defer resp.Body.Close() if _, err := os.Stat(dest); err == nil { if err := os.Remove(dest); err != nil { - return errors.Wrapf(err, "removing %s for overwrite", dest) + return fmt.Errorf("removing %s for overwrite: %w", dest, err) } } fi, err := os.Create(dest) if err != nil { - return errors.Wrapf(err, "creating %s", dest) + return fmt.Errorf("creating %s: %w", dest, err) } defer fi.Close() if _, err := io.Copy(fi, resp.Body); err != nil { - return errors.Wrap(err, "copying binary") + return fmt.Errorf("copying binary: %w", err) } if err := fi.Chmod(0777); err != nil { - return errors.Wrap(err, "fixing perms") + return fmt.Errorf("fixing perms: %w", err) } return nil } @@ -173,7 +172,7 @@ func configure() error { log.Printf("Storing default config.toml at %s", containerdConfigBackupPath) configPath := filepath.Join(nodeDir, containerdConfigPath) if err := mcnutils.CopyFile(configPath, filepath.Join(nodeDir, containerdConfigBackupPath)); err != nil { - return errors.Wrap(err, "copying default config.toml") + return fmt.Errorf("copying default config.toml: %w", err) } // Append runsc configuration to contained config. @@ -182,7 +181,7 @@ func configure() error { return err } if _, err := config.WriteString(configFragment); err != nil { - return errors.Wrap(err, "changing config.toml") + return fmt.Errorf("changing config.toml: %w", err) } return nil } @@ -194,21 +193,21 @@ func restartContainerd() error { cmd := exec.Command("/usr/sbin/chroot", "/node", "sudo", "systemctl", "stop", "rpc-statd.service") if out, err := cmd.CombinedOutput(); err != nil { fmt.Println(string(out)) - return errors.Wrap(err, "stopping rpc-statd.service") + return fmt.Errorf("stopping rpc-statd.service: %w", err) } log.Print("Restarting containerd...") cmd = exec.Command("/usr/sbin/chroot", "/node", "sudo", "systemctl", "restart", "containerd") if out, err := cmd.CombinedOutput(); err != nil { log.Print(string(out)) - return errors.Wrap(err, "restarting containerd") + return fmt.Errorf("restarting containerd: %w", err) } log.Print("Starting rpc-statd...") cmd = exec.Command("/usr/sbin/chroot", "/node", "sudo", "systemctl", "start", "rpc-statd.service") if out, err := cmd.CombinedOutput(); err != nil { log.Print(string(out)) - return errors.Wrap(err, "restarting rpc-statd.service") + return fmt.Errorf("restarting rpc-statd.service: %w", err) } log.Print("containerd restart complete") return nil diff --git a/pkg/minikube/assets/addons.go b/pkg/minikube/assets/addons.go index 291d91f598..7fe9a0f293 100644 --- a/pkg/minikube/assets/addons.go +++ b/pkg/minikube/assets/addons.go @@ -24,7 +24,6 @@ import ( "time" semver "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/minikube/deploy/addons" "k8s.io/minikube/pkg/minikube/config" @@ -909,7 +908,7 @@ func GenerateTemplateData(addon *Addon, cc *config.ClusterConfig, netInfo Networ v, err := util.ParseKubernetesVersion(cfg.KubernetesVersion) if err != nil { - return errors.Wrap(err, "parsing Kubernetes version") + return fmt.Errorf("parsing Kubernetes version: %w", err) } opts := struct { diff --git a/pkg/minikube/assets/vm_assets.go b/pkg/minikube/assets/vm_assets.go index d9fe84a178..46e0bbbe1e 100644 --- a/pkg/minikube/assets/vm_assets.go +++ b/pkg/minikube/assets/vm_assets.go @@ -29,7 +29,7 @@ import ( "text/template" "time" - "github.com/pkg/errors" + "errors" "k8s.io/klog/v2" ) @@ -165,7 +165,7 @@ func NewFileAsset(src, targetDir, targetName, permissions string) (*FileAsset, e info, err := os.Stat(src) if err != nil { - return nil, errors.Wrapf(err, "stat") + return nil, fmt.Errorf("stat: %w", err) } if info.Size() == 0 { @@ -174,7 +174,7 @@ func NewFileAsset(src, targetDir, targetName, permissions string) (*FileAsset, e f, err := os.Open(src) if err != nil { - return nil, errors.Wrap(err, "open") + return nil, fmt.Errorf("open: %w", err) } return &FileAsset{ @@ -385,7 +385,7 @@ func (m *BinAsset) IsTemplate() bool { // Evaluate evaluates the template to a new asset func (m *BinAsset) Evaluate(data interface{}) (*MemoryAsset, error) { if !m.IsTemplate() { - return nil, errors.Errorf("the asset %s is not a template", m.SourcePath) + return nil, fmt.Errorf("the asset %s is not a template", m.SourcePath) } diff --git a/pkg/minikube/bootstrapper/bsutil/binaries.go b/pkg/minikube/bootstrapper/bsutil/binaries.go index f43c4ee80a..a899def70d 100644 --- a/pkg/minikube/bootstrapper/bsutil/binaries.go +++ b/pkg/minikube/bootstrapper/bsutil/binaries.go @@ -24,7 +24,6 @@ import ( "runtime" "strings" - "github.com/pkg/errors" "github.com/spf13/viper" "golang.org/x/sync/errgroup" @@ -65,7 +64,7 @@ func TransferBinaries(cfg config.KubernetesConfig, c command.Runner, sm sysinit. g.Go(func() error { src, err := download.Binary(name, cfg.KubernetesVersion, "linux", runtime.GOARCH, binariesURL) if err != nil { - return errors.Wrapf(err, "downloading %s", name) + return fmt.Errorf("downloading %s: %w", name, err) } if name == "kubelet" && sm.Active(name) { @@ -76,7 +75,7 @@ func TransferBinaries(cfg config.KubernetesConfig, c command.Runner, sm sysinit. dst := path.Join(dir, name) if err := copyBinary(c, src, dst); err != nil { - return errors.Wrapf(err, "copybinary %s -> %s", src, dst) + return fmt.Errorf("copybinary %s -> %s: %w", src, dst, err) } return nil }) @@ -113,7 +112,7 @@ func binRoot(version string) string { func copyBinary(cr command.Runner, src, dest string) error { f, err := assets.NewFileAsset(src, path.Dir(dest), path.Base(dest), "0755") if err != nil { - return errors.Wrap(err, "new file asset") + return fmt.Errorf("new file asset: %w", err) } defer func() { if err := f.Close(); err != nil { @@ -122,7 +121,7 @@ func copyBinary(cr command.Runner, src, dest string) error { }() if err := cr.Copy(f); err != nil { - return errors.Wrapf(err, "copy") + return fmt.Errorf("copy: %w", err) } return nil } diff --git a/pkg/minikube/bootstrapper/bsutil/extraconfig.go b/pkg/minikube/bootstrapper/bsutil/extraconfig.go index 9e71086517..8ffc8c10f6 100644 --- a/pkg/minikube/bootstrapper/bsutil/extraconfig.go +++ b/pkg/minikube/bootstrapper/bsutil/extraconfig.go @@ -24,7 +24,6 @@ import ( "strings" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/config" ) @@ -116,7 +115,7 @@ func FindInvalidExtraConfigFlags(opts config.ExtraOptionSlice) []string { func extraConfigForComponent(component string, opts config.ExtraOptionSlice, version semver.Version) (map[string]string, error) { versionedOpts, err := defaultOptionsForComponentAndVersion(component, version) if err != nil { - return nil, errors.Wrapf(err, "setting version specific options for %s", component) + return nil, fmt.Errorf("setting version specific options for %s: %w", component, err) } for _, opt := range opts { @@ -161,7 +160,7 @@ func newComponentOptions(opts config.ExtraOptionSlice, version semver.Version, f } extraConfig, err := extraConfigForComponent(component, opts, version) if err != nil { - return nil, errors.Wrapf(err, "getting kubeadm extra args for %s", component) + return nil, fmt.Errorf("getting kubeadm extra args for %s: %w", component, err) } if featureGates != "" { extraConfig["feature-gates"] = featureGates diff --git a/pkg/minikube/bootstrapper/bsutil/featuregates.go b/pkg/minikube/bootstrapper/bsutil/featuregates.go index 32fbb5ebdd..fb0ce8d8c4 100644 --- a/pkg/minikube/bootstrapper/bsutil/featuregates.go +++ b/pkg/minikube/bootstrapper/bsutil/featuregates.go @@ -22,7 +22,6 @@ import ( "strconv" "strings" - "github.com/pkg/errors" "k8s.io/minikube/third_party/kubeadm/app/features" ) @@ -60,7 +59,7 @@ func parseFeatureArgs(featureGates string) (map[string]bool, string, error) { boolValue, err := strconv.ParseBool(v) if err != nil { - return nil, "", errors.Wrapf(err, "failed to convert bool value \"%v\"", v) + return nil, "", fmt.Errorf("failed to convert bool value \"%v\": %w", v, err) } kubeadmFeatureArgs[k] = boolValue } diff --git a/pkg/minikube/bootstrapper/bsutil/files.go b/pkg/minikube/bootstrapper/bsutil/files.go index 9a6b7d96d0..abf55e8a78 100644 --- a/pkg/minikube/bootstrapper/bsutil/files.go +++ b/pkg/minikube/bootstrapper/bsutil/files.go @@ -18,9 +18,9 @@ limitations under the License. package bsutil import ( + "fmt" "os/exec" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/command" ) @@ -44,12 +44,12 @@ func CopyFiles(runner command.Runner, files []assets.CopyableFile) error { } args := append([]string{"mkdir", "-p"}, dirs...) if _, err := runner.RunCmd(exec.Command("sudo", args...)); err != nil { - return errors.Wrap(err, "mkdir") + return fmt.Errorf("mkdir: %w", err) } for _, f := range files { if err := runner.Copy(f); err != nil { - return errors.Wrapf(err, "copy") + return fmt.Errorf("copy: %w", err) } } return nil diff --git a/pkg/minikube/bootstrapper/bsutil/kubeadm.go b/pkg/minikube/bootstrapper/bsutil/kubeadm.go index b8d293fd1c..a2c811c35e 100644 --- a/pkg/minikube/bootstrapper/bsutil/kubeadm.go +++ b/pkg/minikube/bootstrapper/bsutil/kubeadm.go @@ -24,7 +24,6 @@ import ( "slices" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/bootstrapper/bsutil/ktmpl" @@ -44,13 +43,13 @@ func GenerateKubeadmYAML(cc config.ClusterConfig, n config.Node, r cruntime.Mana k8s := cc.KubernetesConfig version, err := util.ParseKubernetesVersion(k8s.KubernetesVersion) if err != nil { - return nil, errors.Wrap(err, "parsing Kubernetes version") + return nil, fmt.Errorf("parsing Kubernetes version: %w", err) } // parses a map of the feature gates for kubeadm and component kubeadmFeatureArgs, componentFeatureArgs, err := parseFeatureArgs(k8s.FeatureGates) if err != nil { - return nil, errors.Wrap(err, "parses feature gate config for kubeadm and component") + return nil, fmt.Errorf("parses feature gate config for kubeadm and component: %w", err) } // In case of no port assigned, use default @@ -64,17 +63,17 @@ func GenerateKubeadmYAML(cc config.ClusterConfig, n config.Node, r cruntime.Mana if !r.Active() { return nil, cruntime.ErrContainerRuntimeNotRunning } - return nil, errors.Wrap(err, "getting cgroup driver") + return nil, fmt.Errorf("getting cgroup driver: %w", err) } componentOpts, err := createExtraComponentConfig(k8s.ExtraOptions, version, componentFeatureArgs, n) if err != nil { - return nil, errors.Wrap(err, "generating extra component config for kubeadm") + return nil, fmt.Errorf("generating extra component config for kubeadm: %w", err) } cnm, err := cni.New(&cc) if err != nil { - return nil, errors.Wrap(err, "cni") + return nil, fmt.Errorf("cni: %w", err) } podCIDR := cnm.CIDR() diff --git a/pkg/minikube/bootstrapper/bsutil/kubelet.go b/pkg/minikube/bootstrapper/bsutil/kubelet.go index 83a378a607..d0627509a0 100644 --- a/pkg/minikube/bootstrapper/bsutil/kubelet.go +++ b/pkg/minikube/bootstrapper/bsutil/kubelet.go @@ -24,7 +24,6 @@ import ( "path" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/minikube/bootstrapper/bsutil/ktmpl" "k8s.io/minikube/pkg/minikube/bootstrapper/images" @@ -51,12 +50,12 @@ func extraKubeletOpts(mc config.ClusterConfig, nc config.Node, r cruntime.Manage k8s := mc.KubernetesConfig version, err := util.ParseKubernetesVersion(k8s.KubernetesVersion) if err != nil { - return nil, errors.Wrap(err, "parsing Kubernetes version") + return nil, fmt.Errorf("parsing Kubernetes version: %w", err) } extraOpts, err := extraConfigForComponent(Kubelet, k8s.ExtraOptions, version) if err != nil { - return nil, errors.Wrap(err, "generating extra configuration for kubelet") + return nil, fmt.Errorf("generating extra configuration for kubelet: %w", err) } for k, v := range r.KubeletOptions() { @@ -110,7 +109,7 @@ func extraKubeletOpts(mc config.ClusterConfig, nc config.Node, r cruntime.Manage // parses a map of the feature gates for kubelet _, kubeletFeatureArgs, err := parseFeatureArgs(k8s.FeatureGates) if err != nil { - return nil, errors.Wrap(err, "parses feature gate config for kubelet") + return nil, fmt.Errorf("parses feature gate config for kubelet: %w", err) } if kubeletFeatureArgs != "" { @@ -155,7 +154,7 @@ func NewKubeletService(cfg config.KubernetesConfig) ([]byte, error) { var b bytes.Buffer opts := struct{ KubeletPath string }{KubeletPath: path.Join(binRoot(cfg.KubernetesVersion), "kubelet")} if err := ktmpl.KubeletServiceTemplate.Execute(&b, opts); err != nil { - return nil, errors.Wrap(err, "template execute") + return nil, fmt.Errorf("template execute: %w", err) } return b.Bytes(), nil } diff --git a/pkg/minikube/bootstrapper/bsutil/kverify/api_server.go b/pkg/minikube/bootstrapper/bsutil/kverify/api_server.go index b7c6e46330..5d8c48e0cc 100644 --- a/pkg/minikube/bootstrapper/bsutil/kverify/api_server.go +++ b/pkg/minikube/bootstrapper/bsutil/kverify/api_server.go @@ -32,7 +32,6 @@ import ( "strings" "time" - "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/version" "k8s.io/client-go/kubernetes" @@ -136,7 +135,7 @@ func WaitForHealthyAPIServer(r cruntime.Manager, bs bootstrapper.Bootstrapper, c func APIServerVersionMatch(client *kubernetes.Clientset, expected string) error { vi, err := client.ServerVersion() if err != nil { - return errors.Wrap(err, "server version") + return fmt.Errorf("server version: %w", err) } klog.Infof("control plane version: %s", vi) if version.CompareKubeAwareVersionStrings(vi.String(), expected) != 0 { diff --git a/pkg/minikube/bootstrapper/bsutil/kverify/default_sa.go b/pkg/minikube/bootstrapper/bsutil/kverify/default_sa.go index ea8ae4fdac..aff0c59000 100644 --- a/pkg/minikube/bootstrapper/bsutil/kverify/default_sa.go +++ b/pkg/minikube/bootstrapper/bsutil/kverify/default_sa.go @@ -19,9 +19,9 @@ package kverify import ( "context" + "fmt" "time" - "github.com/pkg/errors" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/kubernetes" @@ -49,7 +49,7 @@ func WaitForDefaultSA(cs *kubernetes.Clientset, timeout time.Duration) error { return false, nil } if err := wait.PollUntilContextTimeout(context.Background(), kconst.APICallRetryInterval, timeout, true, saReady); err != nil { - return errors.Wrapf(err, "waited %s for SA", time.Since(start)) + return fmt.Errorf("waited %s for SA: %w", time.Since(start), err) } klog.Infof("duration metric: took %s for default service account to be created ...", time.Since(start)) diff --git a/pkg/minikube/bootstrapper/bsutil/kverify/node_conditions.go b/pkg/minikube/bootstrapper/bsutil/kverify/node_conditions.go index 2e1a5c379f..433797fc1a 100644 --- a/pkg/minikube/bootstrapper/bsutil/kverify/node_conditions.go +++ b/pkg/minikube/bootstrapper/bsutil/kverify/node_conditions.go @@ -22,7 +22,6 @@ import ( "fmt" "time" - "github.com/pkg/errors" v1 "k8s.io/api/core/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" @@ -115,7 +114,7 @@ func NodePressure(cs *kubernetes.Clientset) error { err = retry.Expo(listNodes, kconst.APICallRetryInterval, 2*time.Minute) if err != nil { - return errors.Wrap(err, "list nodes retry") + return fmt.Errorf("list nodes retry: %w", err) } for _, n := range ns.Items { diff --git a/pkg/minikube/bootstrapper/bsutil/kverify/system_pods.go b/pkg/minikube/bootstrapper/bsutil/kverify/system_pods.go index 9f1dc9f229..ba59e7d950 100644 --- a/pkg/minikube/bootstrapper/bsutil/kverify/system_pods.go +++ b/pkg/minikube/bootstrapper/bsutil/kverify/system_pods.go @@ -24,7 +24,6 @@ import ( "strings" "time" - "github.com/pkg/errors" core "k8s.io/api/core/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" @@ -121,7 +120,7 @@ func WaitForAppsRunning(cs *kubernetes.Clientset, expected []string, timeout tim } if err := retry.Local(checkRunning, timeout); err != nil { - return errors.Wrapf(err, "expected k8s-apps") + return fmt.Errorf("expected k8s-apps: %w", err) } klog.Infof("duration metric: took %s to wait for k8s-apps to be running ...", time.Since(start)) return nil diff --git a/pkg/minikube/bootstrapper/bsutil/ops.go b/pkg/minikube/bootstrapper/bsutil/ops.go index 78d6a58a04..373112dbea 100644 --- a/pkg/minikube/bootstrapper/bsutil/ops.go +++ b/pkg/minikube/bootstrapper/bsutil/ops.go @@ -17,10 +17,10 @@ limitations under the License. package bsutil import ( + "fmt" "os/exec" "strings" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/command" ) @@ -29,7 +29,7 @@ import ( func AdjustResourceLimits(c command.Runner) error { rr, err := c.RunCmd(exec.Command("/bin/bash", "-c", "cat /proc/$(pgrep kube-apiserver)/oom_adj")) if err != nil { - return errors.Wrapf(err, "oom_adj check cmd %s. ", rr.Command()) + return fmt.Errorf("oom_adj check cmd %s. : %w", rr.Command(), err) } klog.Infof("apiserver oom_adj: %s", rr.Stdout.String()) // oom_adj is already a negative number @@ -41,7 +41,7 @@ func AdjustResourceLimits(c command.Runner) error { // Prevent the apiserver from OOM'ing before other pods, as it is our gateway into the cluster. // It'd be preferable to do this via Kubernetes, but kubeadm doesn't have a way to set pod QoS. if _, err = c.RunCmd(exec.Command("/bin/bash", "-c", "echo -10 | sudo tee /proc/$(pgrep kube-apiserver)/oom_adj")); err != nil { - return errors.Wrap(err, "oom_adj adjust") + return fmt.Errorf("oom_adj adjust: %w", err) } return nil } diff --git a/pkg/minikube/bootstrapper/certs.go b/pkg/minikube/bootstrapper/certs.go index 713442afa0..4f4cee5c24 100644 --- a/pkg/minikube/bootstrapper/certs.go +++ b/pkg/minikube/bootstrapper/certs.go @@ -33,7 +33,6 @@ import ( "path/filepath" "github.com/otiai10/copy" - "github.com/pkg/errors" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/tools/clientcmd/api" @@ -69,7 +68,7 @@ func SetupCerts(k8s config.ClusterConfig, n config.Node, pcpCmd command.Runner, sharedCerts, regen, err := generateSharedCACerts() if err != nil { - return errors.Wrap(err, "generate shared ca certs") + return fmt.Errorf("generate shared ca certs: %w", err) } xfer := []string{ @@ -83,7 +82,7 @@ func SetupCerts(k8s config.ClusterConfig, n config.Node, pcpCmd command.Runner, if n.ControlPlane || regen { profileCerts, err := generateProfileCerts(k8s, n, sharedCerts, regen) if err != nil { - return errors.Wrap(err, "generate profile certs") + return fmt.Errorf("generate profile certs: %w", err) } xfer = append(xfer, profileCerts...) } @@ -101,14 +100,14 @@ func SetupCerts(k8s config.ClusterConfig, n config.Node, pcpCmd command.Runner, // note: src(c) is user os' path, dst is kic/iso (linux) path certFile, err := assets.NewFileAsset(c, vmpath.GuestKubernetesCertsDir, filepath.Base(c), properPerms(c)) if err != nil { - return errors.Wrapf(err, "create cert file asset for %s", c) + return fmt.Errorf("create cert file asset for %s: %w", c, err) } copyableFiles = append(copyableFiles, certFile) } caCerts, err := collectCACerts() if err != nil { - return errors.Wrap(err, "collect ca certs") + return fmt.Errorf("collect ca certs: %w", err) } for src, dst := range caCerts { @@ -116,7 +115,7 @@ func SetupCerts(k8s config.ClusterConfig, n config.Node, pcpCmd command.Runner, // note: src is user os' path, dst is kic/iso (linux) path certFile, err := assets.NewFileAsset(src, path.Dir(dst), path.Base(dst), "0644") if err != nil { - return errors.Wrapf(err, "create ca cert file asset for %s", src) + return fmt.Errorf("create ca cert file asset for %s: %w", src, err) } copyableFiles = append(copyableFiles, certFile) } @@ -162,11 +161,11 @@ func SetupCerts(k8s config.ClusterConfig, n config.Node, pcpCmd command.Runner, kubeCfg := api.NewConfig() err = kubeconfig.PopulateFromSettings(kcs, kubeCfg) if err != nil { - return errors.Wrap(err, "populating kubeconfig") + return fmt.Errorf("populating kubeconfig: %w", err) } data, err := runtime.Encode(latest.Codec, kubeCfg) if err != nil { - return errors.Wrap(err, "encoding kubeconfig") + return fmt.Errorf("encoding kubeconfig: %w", err) } kubeCfgFile := assets.NewMemoryAsset(data, vmpath.GuestPersistentDir, "kubeconfig", "0644") copyableFiles = append(copyableFiles, kubeCfgFile) @@ -174,16 +173,16 @@ func SetupCerts(k8s config.ClusterConfig, n config.Node, pcpCmd command.Runner, for _, f := range copyableFiles { if err := cmd.Copy(f); err != nil { - return errors.Wrapf(err, "Copy %s", f.GetSourcePath()) + return fmt.Errorf("Copy %s: %w", f.GetSourcePath(), err) } } if err := installCertSymlinks(cmd, caCerts); err != nil { - return errors.Wrap(err, "install cert symlinks") + return fmt.Errorf("install cert symlinks: %w", err) } if err := renewExpiredKubeadmCerts(cmd, k8s); err != nil { - return errors.Wrap(err, "renew expired kubeadm certs") + return fmt.Errorf("renew expired kubeadm certs: %w", err) } return nil @@ -226,7 +225,7 @@ func generateSharedCACerts() (sharedCACerts, bool, error) { klog.Infof("acquiring lock for ca certs: %+v", spec) releaser, err := lock.Acquire(spec) if err != nil { - return cc, false, errors.Wrapf(err, "acquire lock for ca certs %+v", spec) + return cc, false, fmt.Errorf("acquire lock for ca certs %+v: %w", spec, err) } defer releaser.Release() @@ -239,7 +238,7 @@ func generateSharedCACerts() (sharedCACerts, bool, error) { regenProfileCerts = true klog.Infof("generating %q ca cert: %s", ca.subject, ca.keyPath) if err := util.GenerateCACert(ca.certPath, ca.keyPath, ca.subject); err != nil { - return cc, false, errors.Wrapf(err, "generate %q ca cert: %s", ca.subject, ca.keyPath) + return cc, false, fmt.Errorf("generate %q ca cert: %s: %w", ca.subject, ca.keyPath, err) } } @@ -259,7 +258,7 @@ func generateProfileCerts(cfg config.ClusterConfig, n config.Node, shared shared serviceIP, err := util.ServiceClusterIP(k8s.ServiceCIDR) if err != nil { - return nil, errors.Wrap(err, "get service cluster ip") + return nil, fmt.Errorf("get service cluster ip: %w", err) } apiServerIPs := append([]net.IP{}, k8s.APIServerIPs...) @@ -374,17 +373,17 @@ func generateProfileCerts(cfg config.ClusterConfig, n config.Node, shared shared cfg.CertExpiration, ) if err != nil { - return nil, errors.Wrapf(err, "generate signed profile cert for %q", spec.subject) + return nil, fmt.Errorf("generate signed profile cert for %q: %w", spec.subject, err) } if spec.hash != "" { klog.Infof("copying %s -> %s", cp, spec.certPath) if err := copy.Copy(cp, spec.certPath); err != nil { - return nil, errors.Wrap(err, "copy profile cert") + return nil, fmt.Errorf("copy profile cert: %w", err) } klog.Infof("copying %s -> %s", kp, spec.keyPath) if err := copy.Copy(kp, spec.keyPath); err != nil { - return nil, errors.Wrap(err, "copy profile cert key") + return nil, fmt.Errorf("copy profile cert key: %w", err) } } } @@ -420,7 +419,7 @@ func renewExpiredKubeadmCerts(cmd command.Runner, cc config.ClusterConfig) error out.WarningT("kubeadm certificates have expired. Generating new ones...") bashCmd := fmt.Sprintf("%s certs renew all --config %s", bsutil.KubeadmCmdWithPath(cc.KubernetesConfig.KubernetesVersion), constants.KubeadmYamlPath) if _, err := cmd.RunCmd(exec.Command("sudo", "/bin/bash", "-c", bashCmd)); err != nil { - return errors.Wrap(err, "kubeadm certs renew") + return fmt.Errorf("kubeadm certs renew: %w", err) } return nil } @@ -497,7 +496,7 @@ func collectCACerts() (map[string]string, error) { }) if err != nil { - return nil, errors.Wrapf(err, "collecting CA certs from %s", certsDir) + return nil, fmt.Errorf("collecting CA certs from %s: %w", certsDir, err) } excluded := []string{"ca.pem", "cert.pem"} @@ -529,7 +528,7 @@ func getSubjectHash(cr command.Runner, filePath string) (string, error) { rr, err := cr.RunCmd(exec.Command("openssl", "x509", "-hash", "-noout", "-in", filePath)) if err != nil { crr, _ := cr.RunCmd(exec.Command("cat", filePath)) - return "", errors.Wrapf(err, "cert:\n%s\n---\n%s", lrr.Output(), crr.Stdout.String()) + return "", fmt.Errorf("cert:\n%s\n---\n%s: %w", lrr.Output(), crr.Stdout.String(), err) } stringHash := strings.TrimSpace(rr.Stdout.String()) return stringHash, nil @@ -553,10 +552,10 @@ func installCertSymlinks(cr command.Runner, caCerts map[string]string) error { certStorePath := path.Join(vmpath.GuestCertStoreDir, dstFilename) // to avoid shell-based command exploitation will run these separately not in one command if _, err := cr.RunCmd(exec.Command("sudo", "test", "-s", caCertFile)); err != nil { - return errors.Wrapf(err, "verify ca cert %s", caCertFile) + return fmt.Errorf("verify ca cert %s: %w", caCertFile, err) } if _, err := cr.RunCmd(exec.Command("sudo", "ln", "-fs", caCertFile, certStorePath)); err != nil { - return errors.Wrapf(err, "create symlink for %s", caCertFile) + return fmt.Errorf("create symlink for %s: %w", caCertFile, err) } if !hasSSLBinary { @@ -565,7 +564,7 @@ func installCertSymlinks(cr command.Runner, caCerts map[string]string) error { subjectHash, err := getSubjectHash(cr, caCertFile) if err != nil { - return errors.Wrapf(err, "calculate hash for cacert %s", caCertFile) + return fmt.Errorf("calculate hash for cacert %s: %w", caCertFile, err) } subjectHashLink := path.Join(vmpath.GuestCertStoreDir, fmt.Sprintf("%s.0", subjectHash)) @@ -575,7 +574,7 @@ func installCertSymlinks(cr command.Runner, caCerts map[string]string) error { continue } if _, err := cr.RunCmd(exec.Command("sudo", "ln", "-fs", certStorePath, subjectHashLink)); err != nil { - return errors.Wrapf(err, "create symlink for %s", caCertFile) + return fmt.Errorf("create symlink for %s: %w", caCertFile, err) } } return nil diff --git a/pkg/minikube/bootstrapper/images/kubeadm.go b/pkg/minikube/bootstrapper/images/kubeadm.go index 31dca93a8b..ce7514a7e7 100644 --- a/pkg/minikube/bootstrapper/images/kubeadm.go +++ b/pkg/minikube/bootstrapper/images/kubeadm.go @@ -21,14 +21,13 @@ import ( "strings" "github.com/blang/semver/v4" - "github.com/pkg/errors" ) // Kubeadm returns a list of images necessary to bootstrap kubeadm func Kubeadm(mirror string, version string) ([]string, error) { v, err := semver.Make(strings.TrimPrefix(version, "v")) if err != nil { - return nil, errors.Wrap(err, "semver") + return nil, fmt.Errorf("semver: %w", err) } if v.Major > 1 { return nil, fmt.Errorf("version too new: %v", v) diff --git a/pkg/minikube/bootstrapper/kubeadm/kubeadm.go b/pkg/minikube/bootstrapper/kubeadm/kubeadm.go index c27c7ad5ec..5fad4859db 100644 --- a/pkg/minikube/bootstrapper/kubeadm/kubeadm.go +++ b/pkg/minikube/bootstrapper/kubeadm/kubeadm.go @@ -34,7 +34,6 @@ import ( // WARNING: Do not use path/filepath in this package unless you want bizarre Windows paths "github.com/blang/semver/v4" - "github.com/pkg/errors" core "k8s.io/api/core/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/util/wait" @@ -135,7 +134,7 @@ func (k *Bootstrapper) createCompatSymlinks() error { c := exec.Command("sudo", "ln", "-s", legacyEtcd, bsutil.EtcdDataDir()) if rr, err := k.c.RunCmd(c); err != nil { - return errors.Wrapf(err, "create symlink failed: %s", rr.Command()) + return fmt.Errorf("create symlink failed: %s: %w", rr.Command(), err) } return nil } @@ -175,7 +174,7 @@ func (k *Bootstrapper) clearStaleConfigs(cfg config.ClusterConfig) { func (k *Bootstrapper) init(cfg config.ClusterConfig, options *run.CommandOptions) error { ver, err := util.ParseKubernetesVersion(cfg.KubernetesConfig.KubernetesVersion) if err != nil { - return errors.Wrap(err, "parsing Kubernetes version") + return fmt.Errorf("parsing Kubernetes version: %w", err) } extraFlags := bsutil.CreateFlagsFromExtraArgs(cfg.KubernetesConfig.ExtraOptions) @@ -245,7 +244,7 @@ func (k *Bootstrapper) init(cfg config.ClusterConfig, options *run.CommandOption wg.Add(1) sc, err := k.c.StartCmd(c) if err != nil { - return errors.Wrap(err, "start") + return fmt.Errorf("start: %w", err) } go outputKubeadmInitSteps(kr, &wg) if _, err := k.c.WaitCmd(sc); err != nil { @@ -256,13 +255,13 @@ func (k *Bootstrapper) init(cfg config.ClusterConfig, options *run.CommandOption if strings.Contains(err.Error(), "'kubeadm': Permission denied") { return ErrNoExecLinux } - return errors.Wrap(err, "wait") + return fmt.Errorf("wait: %w", err) } kw.Close() wg.Wait() if err := k.applyCNI(cfg, true); err != nil { - return errors.Wrap(err, "apply cni") + return fmt.Errorf("apply cni: %w", err) } wg.Add(3) @@ -353,7 +352,7 @@ func (k *Bootstrapper) applyCNI(cfg config.ClusterConfig, registerStep ...bool) cnm, err := cni.New(&cfg) if err != nil { - return errors.Wrap(err, "cni config") + return fmt.Errorf("cni config: %w", err) } if _, ok := cnm.(cni.Disabled); ok { @@ -369,7 +368,7 @@ func (k *Bootstrapper) applyCNI(cfg config.ClusterConfig, registerStep ...bool) } if err := cnm.Apply(k.c); err != nil { - return errors.Wrap(err, "cni apply") + return fmt.Errorf("cni apply: %w", err) } return nil @@ -384,7 +383,7 @@ func (k *Bootstrapper) unpause(cfg config.ClusterConfig) error { ids, err := cr.ListContainers(cruntime.ListContainersOptions{State: cruntime.Paused, Namespaces: []string{"kube-system"}}) if err != nil { - return errors.Wrap(err, "list paused") + return fmt.Errorf("list paused: %w", err) } if len(ids) > 0 { @@ -429,7 +428,7 @@ func (k *Bootstrapper) StartCluster(cfg config.ClusterConfig, options *run.Comma conf := constants.KubeadmYamlPath if _, err := k.c.RunCmd(exec.Command("sudo", "cp", conf+".new", conf)); err != nil { - return errors.Wrap(err, "cp") + return fmt.Errorf("cp: %w", err) } err := k.init(cfg, options) @@ -461,17 +460,17 @@ func (k *Bootstrapper) tunnelToAPIServer(cfg config.ClusterConfig, options *run. m, err := machine.NewAPIClient(options) if err != nil { - return errors.Wrapf(err, "create libmachine api client") + return fmt.Errorf("create libmachine api client: %w", err) } cp, err := config.ControlPlane(cfg) if err != nil { - return errors.Wrapf(err, "get control-plane node") + return fmt.Errorf("get control-plane node: %w", err) } args := []string{"-f", "-NTL", fmt.Sprintf("%d:localhost:8443", cfg.APIServerPort)} if err = machine.CreateSSHShell(m, cfg, cp, args, false); err != nil { - return errors.Wrapf(err, "ssh command") + return fmt.Errorf("ssh command: %w", err) } return nil } @@ -484,7 +483,7 @@ func (k *Bootstrapper) client(ip string, port int) (*kubernetes.Clientset, error cc, err := kapi.ClientConfig(k.contextName) if err != nil { - return nil, errors.Wrap(err, "client config") + return nil, fmt.Errorf("client config: %w", err) } endpoint := fmt.Sprintf("https://%s", net.JoinHostPort(ip, strconv.Itoa(port))) @@ -513,16 +512,16 @@ func (k *Bootstrapper) WaitForNode(cfg config.ClusterConfig, n config.Node, time // TODO: #7706: for better performance we could use k.client inside minikube to avoid asking for external IP:PORT cp, err := config.ControlPlane(cfg) if err != nil { - return errors.Wrap(err, "get control-plane node") + return fmt.Errorf("get control-plane node: %w", err) } hostname, _, port, err := driver.ControlPlaneEndpoint(&cfg, &cp, cfg.Driver) if err != nil { - return errors.Wrap(err, "get control-plane endpoint") + return fmt.Errorf("get control-plane endpoint: %w", err) } client, err := k.client(hostname, port) if err != nil { - return errors.Wrap(err, "kubernetes client") + return fmt.Errorf("kubernetes client: %w", err) } if !kverify.ShouldWait(cfg.VerifyComponents) { @@ -530,7 +529,7 @@ func (k *Bootstrapper) WaitForNode(cfg config.ClusterConfig, n config.Node, time if err := kverify.NodePressure(client); err != nil { adviseNodePressure(err, cfg.Name, cfg.Driver) - return errors.Wrap(err, "node pressure") + return fmt.Errorf("node pressure: %w", err) } return nil } @@ -539,48 +538,48 @@ func (k *Bootstrapper) WaitForNode(cfg config.ClusterConfig, n config.Node, time if cfg.VerifyComponents[kverify.NodeReadyKey] || cfg.VerifyComponents[kverify.ExtraKey] { name := bsutil.KubeNodeName(cfg, n) if err := kverify.WaitNodeCondition(client, name, core.NodeReady, timeout); err != nil { - return errors.Wrap(err, "waiting for node to be ready") + return fmt.Errorf("waiting for node to be ready: %w", err) } } cr, err := cruntime.New(cruntime.Config{Type: cfg.KubernetesConfig.ContainerRuntime, Runner: k.c}) if err != nil { - return errors.Wrapf(err, "create runtme-manager %s", cfg.KubernetesConfig.ContainerRuntime) + return fmt.Errorf("create runtme-manager %s: %w", cfg.KubernetesConfig.ContainerRuntime, err) } if n.ControlPlane { if cfg.VerifyComponents[kverify.APIServerWaitKey] { if err := kverify.WaitForAPIServerProcess(cr, k, cfg, k.c, start, timeout); err != nil { - return errors.Wrap(err, "wait for apiserver proc") + return fmt.Errorf("wait for apiserver proc: %w", err) } if err := kverify.WaitForHealthyAPIServer(cr, k, cfg, k.c, client, start, hostname, port, timeout); err != nil { - return errors.Wrap(err, "wait for healthy API server") + return fmt.Errorf("wait for healthy API server: %w", err) } } if cfg.VerifyComponents[kverify.SystemPodsWaitKey] { if err := kverify.WaitForSystemPods(cr, k, cfg, k.c, client, start, timeout); err != nil { - return errors.Wrap(err, "waiting for system pods") + return fmt.Errorf("waiting for system pods: %w", err) } } if cfg.VerifyComponents[kverify.DefaultSAWaitKey] { if err := kverify.WaitForDefaultSA(client, timeout); err != nil { - return errors.Wrap(err, "waiting for default service account") + return fmt.Errorf("waiting for default service account: %w", err) } } if cfg.VerifyComponents[kverify.AppsRunningKey] { if err := kverify.WaitForAppsRunning(client, kverify.AppsRunningList, timeout); err != nil { - return errors.Wrap(err, "waiting for apps_running") + return fmt.Errorf("waiting for apps_running: %w", err) } } } if cfg.VerifyComponents[kverify.KubeletKey] { if err := kverify.WaitForService(k.c, "kubelet", timeout); err != nil { - return errors.Wrap(err, "waiting for kubelet") + return fmt.Errorf("waiting for kubelet: %w", err) } } @@ -588,7 +587,7 @@ func (k *Bootstrapper) WaitForNode(cfg config.ClusterConfig, n config.Node, time if err := kverify.NodePressure(client); err != nil { adviseNodePressure(err, cfg.Name, cfg.Driver) - return errors.Wrap(err, "node pressure") + return fmt.Errorf("node pressure: %w", err) } return nil } @@ -608,12 +607,12 @@ func (k *Bootstrapper) restartPrimaryControlPlane(cfg config.ClusterConfig) erro pcp, err := config.ControlPlane(cfg) if err != nil || !config.IsPrimaryControlPlane(cfg, pcp) { - return errors.Wrap(err, "get primary control-plane node") + return fmt.Errorf("get primary control-plane node: %w", err) } host, _, port, err := driver.ControlPlaneEndpoint(&cfg, &pcp, cfg.Driver) if err != nil { - return errors.Wrap(err, "get primary control-plane endpoint") + return fmt.Errorf("get primary control-plane endpoint: %w", err) } // Save the costly tax of reinstalling Kubernetes if the only issue is a missing kube context @@ -623,7 +622,7 @@ func (k *Bootstrapper) restartPrimaryControlPlane(cfg config.ClusterConfig) erro client, err := k.client(host, port) if err != nil { - return errors.Wrap(err, "getting k8s client") + return fmt.Errorf("getting k8s client: %w", err) } // If the cluster is running, check if we have any work to do. @@ -656,7 +655,7 @@ func (k *Bootstrapper) restartPrimaryControlPlane(cfg config.ClusterConfig) erro k.clearStaleConfigs(cfg) if _, err := k.c.RunCmd(exec.Command("sudo", "cp", conf+".new", conf)); err != nil { - return errors.Wrap(err, "cp") + return fmt.Errorf("cp: %w", err) } baseCmd := fmt.Sprintf("%s init", bsutil.KubeadmCmdWithPath(cfg.KubernetesConfig.KubernetesVersion)) @@ -674,32 +673,32 @@ func (k *Bootstrapper) restartPrimaryControlPlane(cfg config.ClusterConfig) erro klog.Errorf("%s failed - will try once more: %v", c, err) if _, err := k.c.RunCmd(exec.Command("sudo", "/bin/bash", "-c", c)); err != nil { - return errors.Wrap(err, "run") + return fmt.Errorf("run: %w", err) } } } cr, err := cruntime.New(cruntime.Config{Type: cfg.KubernetesConfig.ContainerRuntime, Runner: k.c}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } // We must ensure that the apiserver is healthy before proceeding if err := kverify.WaitForAPIServerProcess(cr, k, cfg, k.c, time.Now(), kconst.DefaultControlPlaneTimeout); err != nil { - return errors.Wrap(err, "apiserver healthz") + return fmt.Errorf("apiserver healthz: %w", err) } if err := kverify.WaitForHealthyAPIServer(cr, k, cfg, k.c, client, time.Now(), host, port, kconst.DefaultControlPlaneTimeout); err != nil { - return errors.Wrap(err, "apiserver health") + return fmt.Errorf("apiserver health: %w", err) } // because reboots clear /etc/cni if err := k.applyCNI(cfg); err != nil { - return errors.Wrap(err, "apply cni") + return fmt.Errorf("apply cni: %w", err) } if err := kverify.WaitForSystemPods(cr, k, cfg, k.c, client, time.Now(), kconst.DefaultControlPlaneTimeout); err != nil { - return errors.Wrap(err, "system pods") + return fmt.Errorf("system pods: %w", err) } if err := kverify.NodePressure(client); err != nil { @@ -717,7 +716,7 @@ func (k *Bootstrapper) restartPrimaryControlPlane(cfg config.ClusterConfig) erro } if err = retry.Expo(addonPhase, 100*time.Microsecond, 30*time.Second); err != nil { klog.Warningf("addon install failed, wil retry: %v", err) - return errors.Wrap(err, "addons") + return fmt.Errorf("addons: %w", err) } // must be called after applyCNI and `kubeadm phase addon all` (ie, coredns redeploy) @@ -769,11 +768,11 @@ func (k *Bootstrapper) JoinCluster(cc config.ClusterConfig, n config.Node, joinC } if _, err := k.c.RunCmd(exec.Command("sudo", "/bin/bash", "-c", joinCmd)); err != nil { - return errors.Wrapf(err, "kubeadm join") + return fmt.Errorf("kubeadm join: %w", err) } if _, err := k.c.RunCmd(exec.Command("sudo", "/bin/bash", "-c", "systemctl daemon-reload && systemctl enable kubelet && systemctl start kubelet")); err != nil { - return errors.Wrap(err, "starting kubelet") + return fmt.Errorf("starting kubelet: %w", err) } return nil @@ -785,7 +784,7 @@ func (k *Bootstrapper) GenerateToken(cc config.ClusterConfig) (string, error) { tokenCmd := exec.Command("sudo", "/bin/bash", "-c", fmt.Sprintf("%s token create --print-join-command --ttl=0", bsutil.KubeadmCmdWithPath(cc.KubernetesConfig.KubernetesVersion))) r, err := k.c.RunCmd(tokenCmd) if err != nil { - return "", errors.Wrap(err, "generating join command") + return "", fmt.Errorf("generating join command: %w", err) } joinCmd := r.Stdout.String() @@ -795,7 +794,7 @@ func (k *Bootstrapper) GenerateToken(cc config.ClusterConfig) (string, error) { // avoid "Found multiple CRI endpoints on the host. Please define which one do you wish to use by setting the 'criSocket' field in the kubeadm configuration file: unix:///var/run/containerd/containerd.sock, unix:///var/run/cri-dockerd.sock" error ver, err := util.ParseKubernetesVersion(cc.KubernetesConfig.KubernetesVersion) if err != nil { - return "", errors.Wrap(err, "parsing Kubernetes version") + return "", fmt.Errorf("parsing Kubernetes version: %w", err) } cr, err := cruntime.New(cruntime.Config{Type: cc.KubernetesConfig.ContainerRuntime, Runner: k.c, Socket: cc.KubernetesConfig.CRISocket, KubernetesVersion: ver}) if err != nil { @@ -851,11 +850,11 @@ func StopKubernetes(runner command.Runner, cr cruntime.Manager) { func (k *Bootstrapper) DeleteCluster(k8s config.KubernetesConfig) error { ver, err := util.ParseKubernetesVersion(k8s.KubernetesVersion) if err != nil { - return errors.Wrap(err, "parsing Kubernetes version") + return fmt.Errorf("parsing Kubernetes version: %w", err) } cr, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: k.c, Socket: k8s.CRISocket, KubernetesVersion: ver}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } ka := bsutil.KubeadmCmdWithPath(k8s.KubernetesVersion) @@ -885,12 +884,12 @@ func (k *Bootstrapper) UpdateCluster(cfg config.ClusterConfig) error { imgs, err := images.Kubeadm(cfg.KubernetesConfig.ImageRepository, cfg.KubernetesConfig.KubernetesVersion) if err != nil { - return errors.Wrap(err, "kubeadm images") + return fmt.Errorf("kubeadm images: %w", err) } ver, err := util.ParseKubernetesVersion(cfg.KubernetesConfig.KubernetesVersion) if err != nil { - return errors.Wrap(err, "parsing Kubernetes version") + return fmt.Errorf("parsing Kubernetes version: %w", err) } r, err := cruntime.New(cruntime.Config{ Type: cfg.KubernetesConfig.ContainerRuntime, @@ -899,7 +898,7 @@ func (k *Bootstrapper) UpdateCluster(cfg config.ClusterConfig) error { KubernetesVersion: ver, }) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } if err := r.Preload(cfg); err != nil { @@ -919,12 +918,12 @@ func (k *Bootstrapper) UpdateCluster(cfg config.ClusterConfig) error { pcp, err := config.ControlPlane(cfg) if err != nil || !config.IsPrimaryControlPlane(cfg, pcp) { - return errors.Wrap(err, "get primary control-plane node") + return fmt.Errorf("get primary control-plane node: %w", err) } err = k.UpdateNode(cfg, pcp, r) if err != nil { - return errors.Wrap(err, "update primary control-plane node") + return fmt.Errorf("update primary control-plane node: %w", err) } return nil @@ -936,12 +935,12 @@ func (k *Bootstrapper) UpdateNode(cfg config.ClusterConfig, n config.Node, r cru kubeletCfg, err := bsutil.NewKubeletConfig(cfg, n, r) if err != nil { - return errors.Wrap(err, "generating kubelet config") + return fmt.Errorf("generating kubelet config: %w", err) } kubeletService, err := bsutil.NewKubeletService(cfg.KubernetesConfig) if err != nil { - return errors.Wrap(err, "generating kubelet service") + return fmt.Errorf("generating kubelet service: %w", err) } klog.Infof("kubelet %s config:\n%+v", kubeletCfg, cfg.KubernetesConfig) @@ -958,7 +957,7 @@ func (k *Bootstrapper) UpdateNode(cfg config.ClusterConfig, n config.Node, r cru if config.IsPrimaryControlPlane(cfg, n) { kubeadmCfg, err = bsutil.GenerateKubeadmYAML(cfg, n, r) if err != nil { - return errors.Wrap(err, "generating kubeadm cfg") + return fmt.Errorf("generating kubeadm cfg: %w", err) } files = append(files, assets.NewMemoryAssetTarget(kubeadmCfg, constants.KubeadmYamlPath+".new", "0640")) } @@ -969,7 +968,7 @@ func (k *Bootstrapper) UpdateNode(cfg config.ClusterConfig, n config.Node, r cru // TODO (prezha): remove when fixed upstream - ref: https://github.com/kube-vip/kube-vip/issues/684#issuecomment-1864855405 kv, err := semver.ParseTolerant(cfg.KubernetesConfig.KubernetesVersion) if err != nil { - return errors.Wrapf(err, "parsing kubernetes version %q", cfg.KubernetesConfig.KubernetesVersion) + return fmt.Errorf("parsing kubernetes version %q: %w", cfg.KubernetesConfig.KubernetesVersion, err) } workaround := kv.GTE(semver.Version{Major: 1, Minor: 29}) && config.IsPrimaryControlPlane(cfg, n) && len(config.ControlPlanes(cfg)) == 1 kubevipCfg, err := kubevip.Configure(cfg, k.c, kubeadmCfg, workaround) @@ -984,23 +983,23 @@ func (k *Bootstrapper) UpdateNode(cfg config.ClusterConfig, n config.Node, r cru sm := sysinit.New(k.c) if err := bsutil.TransferBinaries(cfg.KubernetesConfig, k.c, sm, cfg.BinaryMirror); err != nil { - return errors.Wrap(err, "downloading binaries") + return fmt.Errorf("downloading binaries: %w", err) } // Installs compatibility shims for non-systemd environments kubeletPath := path.Join(vmpath.GuestPersistentDir, "binaries", cfg.KubernetesConfig.KubernetesVersion, "kubelet") shims, err := sm.GenerateInitShim("kubelet", kubeletPath, bsutil.KubeletSystemdConfFile) if err != nil { - return errors.Wrap(err, "shim") + return fmt.Errorf("shim: %w", err) } files = append(files, shims...) if err := bsutil.CopyFiles(k.c, files); err != nil { - return errors.Wrap(err, "copy") + return fmt.Errorf("copy: %w", err) } if err := k.copyResolvConf(cfg); err != nil { - return errors.Wrap(err, "resolv.conf") + return fmt.Errorf("resolv.conf: %w", err) } // add "control-plane.minikube.internal" dns alias @@ -1009,12 +1008,12 @@ func (k *Bootstrapper) UpdateNode(cfg config.ClusterConfig, n config.Node, r cru if !config.IsHA(cfg) { cp, err := config.ControlPlane(cfg) if err != nil { - return errors.Wrap(err, "get control-plane node") + return fmt.Errorf("get control-plane node: %w", err) } cpIP = cp.IP } if err := machine.AddHostAlias(k.c, constants.ControlPlaneAlias, net.ParseIP(cpIP)); err != nil { - return errors.Wrap(err, "add control-plane alias") + return fmt.Errorf("add control-plane alias: %w", err) } // "ensure" kubelet is started, intentionally non-fatal in case of an error @@ -1033,10 +1032,10 @@ func (k *Bootstrapper) copyResolvConf(cfg config.ClusterConfig) error { return nil } if _, err := k.c.RunCmd(exec.Command("sudo", "cp", "/etc/resolv.conf", "/etc/kubelet-resolv.conf")); err != nil { - return errors.Wrap(err, "copy") + return fmt.Errorf("copy: %w", err) } if _, err := k.c.RunCmd(exec.Command("sudo", "sed", "-i", "-e", "s/^search .$//", "/etc/kubelet-resolv.conf")); err != nil { - return errors.Wrap(err, "sed") + return fmt.Errorf("sed: %w", err) } return nil @@ -1085,9 +1084,9 @@ func (k *Bootstrapper) labelAndUntaintNode(cfg config.ClusterConfig, n config.No "label", "--overwrite", "nodes", nodeName, createdAtLbl, verLbl, commitLbl, profileNameLbl, primaryLbl) if _, err := k.c.RunCmd(cmd); err != nil { if ctx.Err() == context.DeadlineExceeded { - return errors.Wrapf(err, "timeout apply node labels") + return fmt.Errorf("timeout apply node labels: %w", err) } - return errors.Wrapf(err, "apply node labels") + return fmt.Errorf("apply node labels: %w", err) } // primary control-plane and worker nodes should be untainted by default @@ -1098,9 +1097,9 @@ func (k *Bootstrapper) labelAndUntaintNode(cfg config.ClusterConfig, n config.No "taint", "nodes", config.MachineName(cfg, n), "node-role.kubernetes.io/control-plane:NoSchedule-") if _, err := k.c.RunCmd(cmd); err != nil { if ctx.Err() == context.DeadlineExceeded { - return errors.Wrapf(err, "timeout remove node taints") + return fmt.Errorf("timeout remove node taints: %w", err) } - return errors.Wrapf(err, "remove node taints") + return fmt.Errorf("remove node taints: %w", err) } } @@ -1125,13 +1124,13 @@ func (k *Bootstrapper) elevateKubeSystemPrivileges(cfg config.ClusterConfig) err rr, err := k.c.RunCmd(cmd) if err != nil { if ctx.Err() == context.DeadlineExceeded { - return errors.Wrapf(err, "timeout apply sa") + return fmt.Errorf("timeout apply sa: %w", err) } // Error from server (AlreadyExists): clusterrolebindings.rbac.authorization.k8s.io "minikube-rbac" already exists if strings.Contains(rr.Output(), "Error from server (AlreadyExists)") { klog.Infof("rbac %q already exists not need to re-create.", rbacName) } else { - return errors.Wrapf(err, "apply sa") + return fmt.Errorf("apply sa: %w", err) } } @@ -1150,7 +1149,7 @@ func (k *Bootstrapper) elevateKubeSystemPrivileges(cfg config.ClusterConfig) err // retry up to make sure SA is created if err := wait.PollUntilContextTimeout(context.Background(), kconst.APICallRetryInterval, time.Minute, true, checkSA); err != nil { - return errors.Wrap(err, "ensure sa was created") + return fmt.Errorf("ensure sa was created: %w", err) } } return nil @@ -1161,17 +1160,17 @@ func (k *Bootstrapper) stopKubeSystem(cfg config.ClusterConfig) error { klog.Info("stopping kube-system containers ...") cr, err := cruntime.New(cruntime.Config{Type: cfg.KubernetesConfig.ContainerRuntime, Socket: cfg.KubernetesConfig.CRISocket, Runner: k.c}) if err != nil { - return errors.Wrap(err, "new cruntime") + return fmt.Errorf("new cruntime: %w", err) } ids, err := cr.ListContainers(cruntime.ListContainersOptions{Namespaces: []string{"kube-system"}}) if err != nil { - return errors.Wrap(err, "list") + return fmt.Errorf("list: %w", err) } if len(ids) > 0 { if err := cr.StopContainers(ids); err != nil { - return errors.Wrap(err, "stop") + return fmt.Errorf("stop: %w", err) } } return nil diff --git a/pkg/minikube/cluster/cluster.go b/pkg/minikube/cluster/cluster.go index f04a9e29c8..1f71a71788 100644 --- a/pkg/minikube/cluster/cluster.go +++ b/pkg/minikube/cluster/cluster.go @@ -19,7 +19,6 @@ package cluster import ( "fmt" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/ssh" @@ -46,7 +45,7 @@ func Bootstrapper(api libmachine.API, bootstrapperName string, cc config.Cluster case bootstrapper.Kubeadm: b, err = kubeadm.NewBootstrapper(api, cc, r) if err != nil { - return nil, errors.Wrap(err, "getting a new kubeadm bootstrapper") + return nil, fmt.Errorf("getting a new kubeadm bootstrapper: %w", err) } default: return nil, fmt.Errorf("unknown bootstrapper: %s", bootstrapperName) @@ -58,15 +57,15 @@ func Bootstrapper(api libmachine.API, bootstrapperName string, cc config.Cluster func ControlPlaneBootstrapper(mAPI libmachine.API, cc *config.ClusterConfig, bootstrapperName string) (bootstrapper.Bootstrapper, error) { cp, err := config.ControlPlane(*cc) if err != nil { - return nil, errors.Wrap(err, "get primary control-plane node") + return nil, fmt.Errorf("get primary control-plane node: %w", err) } h, err := machine.LoadHost(mAPI, config.MachineName(*cc, cp)) if err != nil { - return nil, errors.Wrap(err, "load primary control-plane host") + return nil, fmt.Errorf("load primary control-plane host: %w", err) } cpr, err := machine.CommandRunner(h) if err != nil { - return nil, errors.Wrap(err, "get primary control-plane command runner") + return nil, fmt.Errorf("get primary control-plane command runner: %w", err) } bs, err := Bootstrapper(mAPI, bootstrapperName, *cc, cpr) diff --git a/pkg/minikube/cluster/ha/kube-vip/kube-vip.go b/pkg/minikube/cluster/ha/kube-vip/kube-vip.go index 5fa9a9ae11..a685c02be2 100644 --- a/pkg/minikube/cluster/ha/kube-vip/kube-vip.go +++ b/pkg/minikube/cluster/ha/kube-vip/kube-vip.go @@ -18,11 +18,11 @@ package kubevip import ( "bytes" + "fmt" "html/template" "os/exec" "strings" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/command" "k8s.io/minikube/pkg/minikube/config" @@ -131,7 +131,7 @@ func Configure(cc config.ClusterConfig, r command.Runner, kubeadmCfg []byte, wor b := bytes.Buffer{} if err := kubeVipTemplate.Execute(&b, params); err != nil { - return nil, errors.Wrapf(err, "parse template") + return nil, fmt.Errorf("parse template: %w", err) } klog.Infof("kube-vip config:\n%s", b.String()) diff --git a/pkg/minikube/cluster/ip.go b/pkg/minikube/cluster/ip.go index e3a69fef14..2dc7edc507 100644 --- a/pkg/minikube/cluster/ip.go +++ b/pkg/minikube/cluster/ip.go @@ -24,7 +24,8 @@ import ( "regexp" "strings" - "github.com/pkg/errors" + "errors" + "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/libmachine" @@ -43,25 +44,25 @@ func HostIP(hostInfo *host.Host, clusterName string) (net.IP, error) { case driver.SSH: ip, err := hostInfo.Driver.GetIP() if err != nil { - return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address") + return []byte{}, fmt.Errorf("Error getting VM/Host IP address: %w", err) } return net.ParseIP(ip), nil case driver.KVM2: // `host.Driver.GetIP` returns dhcp lease info for a given network(=`virsh net-dhcp-leases minikube-net`) vmIPString, err := hostInfo.Driver.GetIP() if err != nil { - return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address") + return []byte{}, fmt.Errorf("Error getting VM/Host IP address: %w", err) } vmIP := net.ParseIP(vmIPString).To4() if vmIP == nil { // We need the network ip address for minikube-net. It's the start address of the returned subnet. - return []byte{}, errors.Wrap(err, "Error converting VM/Host IP address to IPv4 address") + return []byte{}, fmt.Errorf("Error converting VM/Host IP address to IPv4 address: %w", err) } return net.IPv4(vmIP[0], vmIP[1], vmIP[2], byte(1)), nil case driver.QEMU, driver.QEMU2: ipString, err := hostInfo.Driver.GetIP() if err != nil { - return []byte{}, errors.Wrap(err, "Error getting IP address") + return []byte{}, fmt.Errorf("Error getting IP address: %w", err) } if ipString == "127.0.0.1" { // user network case @@ -85,7 +86,7 @@ func HostIP(hostInfo *host.Host, clusterName string) (net.IP, error) { } ip, err := getIPForInterface(fmt.Sprintf("vEthernet (%s)", hypervVirtualSwitch)) if err != nil { - return []byte{}, errors.Wrap(err, fmt.Sprintf("ip for interface (%s)", hypervVirtualSwitch)) + return []byte{}, fmt.Errorf("%s: %w", fmt.Sprintf("ip for interface (%s)", hypervVirtualSwitch), err) } return ip, nil @@ -93,13 +94,13 @@ func HostIP(hostInfo *host.Host, clusterName string) (net.IP, error) { vBoxManageCmd := driver.VBoxManagePath() out, err := exec.Command(vBoxManageCmd, "showvminfo", hostInfo.Name, "--machinereadable").Output() if err != nil { - return []byte{}, errors.Wrap(err, "vboxmanage") + return []byte{}, fmt.Errorf("vboxmanage: %w", err) } re := regexp.MustCompile(`hostonlyadapter2="(.*?)"`) iface := re.FindStringSubmatch(string(out))[1] ipList, err := exec.Command(vBoxManageCmd, "list", "hostonlyifs").Output() if err != nil { - return []byte{}, errors.Wrap(err, "Error getting VM/Host IP address") + return []byte{}, fmt.Errorf("Error getting VM/Host IP address: %w", err) } re = regexp.MustCompile(`(?sm)Name:\s*` + iface + `\s*$.+?IPAddress:\s*(\S+)`) ip := re.FindStringSubmatch(string(ipList))[1] @@ -115,12 +116,12 @@ func HostIP(hostInfo *host.Host, clusterName string) (net.IP, error) { } out, err := exec.Command(binPath, "net", "info", "Shared").Output() if err != nil { - return []byte{}, errors.Wrap(err, "Error reading the info of Parallels Shared network interface") + return []byte{}, fmt.Errorf("Error reading the info of Parallels Shared network interface: %w", err) } re := regexp.MustCompile(`IPv4 address: (.*)`) ipMatch := re.FindStringSubmatch(string(out)) if len(ipMatch) < 2 { - return []byte{}, errors.Wrap(err, "Error getting the IP address of Parallels Shared network interface") + return []byte{}, fmt.Errorf("Error getting the IP address of Parallels Shared network interface: %w", err) } ip := ipMatch[1] @@ -132,11 +133,11 @@ func HostIP(hostInfo *host.Host, clusterName string) (net.IP, error) { case driver.VMware: vmIPString, err := hostInfo.Driver.GetIP() if err != nil { - return []byte{}, errors.Wrap(err, "Error getting VM IP address") + return []byte{}, fmt.Errorf("Error getting VM IP address: %w", err) } vmIP := net.ParseIP(vmIPString).To4() if vmIP == nil { - return []byte{}, errors.Wrap(err, "Error converting VM IP address to IPv4 address") + return []byte{}, fmt.Errorf("Error converting VM IP address to IPv4 address: %w", err) } return net.IPv4(vmIP[0], vmIP[1], vmIP[2], byte(1)), nil case driver.VFKit, driver.Krunkit: @@ -163,7 +164,7 @@ func DriverIP(api libmachine.API, machineName string) (net.IP, error) { ipStr, err := hostInfo.Driver.GetIP() if err != nil { - return nil, errors.Wrap(err, "getting IP") + return nil, fmt.Errorf("getting IP: %w", err) } if driver.IsKIC(hostInfo.DriverName) { ipStr = oci.DefaultBindIPV4 @@ -209,7 +210,7 @@ func getIPForInterface(name string) (net.IP, error) { // We found nothing, fail out if i.Name == "" { - return nil, errors.Errorf("Could not find interface %s inside %+v", name, ints) + return nil, fmt.Errorf("Could not find interface %s inside %+v", name, ints) } klog.Infof("Found interface: %+v\n", i) @@ -222,5 +223,5 @@ func getIPForInterface(name string) (net.IP, error) { } } } - return nil, errors.Errorf("Unable to find a IPv4 address for interface %q", name) + return nil, fmt.Errorf("Unable to find a IPv4 address for interface %q", name) } diff --git a/pkg/minikube/cluster/mount.go b/pkg/minikube/cluster/mount.go index 1670fbdaff..85bff192ed 100644 --- a/pkg/minikube/cluster/mount.go +++ b/pkg/minikube/cluster/mount.go @@ -24,7 +24,6 @@ import ( "strconv" "strings" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/command" @@ -82,11 +81,11 @@ func (m *MountError) Error() string { // Mount runs the mount command from the 9p client on the VM to the 9p server on the host func Mount(r mountRunner, source string, target string, c *MountConfig, pid int) error { if err := Unmount(r, target); err != nil { - return &MountError{ErrorType: MountErrorUnknown, UnderlyingError: errors.Wrap(err, "umount")} + return &MountError{ErrorType: MountErrorUnknown, UnderlyingError: fmt.Errorf("umount: %w", err)} } if _, err := r.RunCmd(exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo mkdir -p %s", target))); err != nil { - return &MountError{ErrorType: MountErrorUnknown, UnderlyingError: errors.Wrap(err, "create folder pre-mount")} + return &MountError{ErrorType: MountErrorUnknown, UnderlyingError: fmt.Errorf("create folder pre-mount: %w", err)} } rr, err := r.RunCmd(exec.Command("/bin/bash", "-c", mntCmd(source, target, c))) @@ -94,7 +93,7 @@ func Mount(r mountRunner, source string, target string, c *MountConfig, pid int) if strings.Contains(rr.Stderr.String(), "Connection timed out") { return &MountError{ErrorType: MountErrorConnect, UnderlyingError: err} } - return &MountError{ErrorType: MountErrorUnknown, UnderlyingError: errors.Wrapf(err, "mount with cmd %s ", rr.Command())} + return &MountError{ErrorType: MountErrorUnknown, UnderlyingError: fmt.Errorf("mount with cmd %s : %w", rr.Command(), err)} } profile := viper.GetString("profile") @@ -175,7 +174,7 @@ func Unmount(r mountRunner, target string) error { // grep because findmnt will also display the parent! c := exec.Command("/bin/bash", "-c", fmt.Sprintf("[ \"x$(findmnt -T %s | grep %s)\" != \"x\" ] && sudo umount -f -l %s || echo ", target, target, target)) if _, err := r.RunCmd(c); err != nil { - return errors.Wrap(err, "unmount") + return fmt.Errorf("unmount: %w", err) } klog.Infof("unmount for %s ran successfully", target) return nil diff --git a/pkg/minikube/cluster/pause.go b/pkg/minikube/cluster/pause.go index a467d142ea..543c5ab107 100644 --- a/pkg/minikube/cluster/pause.go +++ b/pkg/minikube/cluster/pause.go @@ -17,10 +17,10 @@ limitations under the License. package cluster import ( + "fmt" "slices" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/command" "k8s.io/minikube/pkg/minikube/cruntime" @@ -52,12 +52,12 @@ func pause(cr cruntime.Manager, r command.Runner, namespaces []string) ([]string klog.Info("kubelet running: ", sm.Active("kubelet")) if err := sm.DisableNow("kubelet"); err != nil { - return ids, errors.Wrap(err, "kubelet disable --now") + return ids, fmt.Errorf("kubelet disable --now: %w", err) } ids, err := cr.ListContainers(cruntime.ListContainersOptions{State: cruntime.Running, Namespaces: namespaces}) if err != nil { - return ids, errors.Wrap(err, "list running") + return ids, fmt.Errorf("list running: %w", err) } if len(ids) == 0 { @@ -66,7 +66,7 @@ func pause(cr cruntime.Manager, r command.Runner, namespaces []string) ([]string } if err := cr.PauseContainers(ids); err != nil { - return ids, errors.Wrap(err, "pausing containers") + return ids, fmt.Errorf("pausing containers: %w", err) } if doesNamespaceContainKubeSystem(namespaces) { @@ -94,19 +94,19 @@ func Unpause(cr cruntime.Manager, r command.Runner, namespaces []string) ([]stri func unpause(cr cruntime.Manager, r command.Runner, namespaces []string) ([]string, error) { ids, err := cr.ListContainers(cruntime.ListContainersOptions{State: cruntime.Paused, Namespaces: namespaces}) if err != nil { - return ids, errors.Wrap(err, "list paused") + return ids, fmt.Errorf("list paused: %w", err) } if len(ids) == 0 { klog.Warningf("no paused containers found") } else if err := cr.UnpauseContainers(ids); err != nil { - return ids, errors.Wrap(err, "unpause") + return ids, fmt.Errorf("unpause: %w", err) } sm := sysinit.New(r) if err := sm.Start("kubelet"); err != nil { - return ids, errors.Wrap(err, "kubelet start") + return ids, fmt.Errorf("kubelet start: %w", err) } if doesNamespaceContainKubeSystem(namespaces) { @@ -120,7 +120,7 @@ func unpause(cr cruntime.Manager, r command.Runner, namespaces []string) ([]stri func CheckIfPaused(cr cruntime.Manager, namespaces []string) (bool, error) { ids, err := cr.ListContainers(cruntime.ListContainersOptions{State: cruntime.Paused, Namespaces: namespaces}) if err != nil { - return true, errors.Wrap(err, "list paused") + return true, fmt.Errorf("list paused: %w", err) } if len(ids) > 0 { diff --git a/pkg/minikube/cluster/status.go b/pkg/minikube/cluster/status.go index d04d6f1522..2d3bf0e7fa 100644 --- a/pkg/minikube/cluster/status.go +++ b/pkg/minikube/cluster/status.go @@ -26,7 +26,6 @@ import ( "time" cloudevents "github.com/cloudevents/sdk-go/v2" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/state" @@ -370,7 +369,7 @@ func NodeStatus(api libmachine.API, cc config.ClusterConfig, n config.Node) (*St hs, err := machine.Status(api, name) klog.Infof("%s host status = %q (err=%v)", name, hs, err) if err != nil { - return st, errors.Wrap(err, "host") + return st, fmt.Errorf("host: %w", err) } // We have no record of this host. Return nonexistent struct @@ -478,12 +477,12 @@ func readEventLog(name string) ([]cloudevents.Event, time.Time, error) { st, err := os.Stat(path) if err != nil { - return nil, time.Time{}, errors.Wrap(err, "stat") + return nil, time.Time{}, fmt.Errorf("stat: %w", err) } f, err := os.Open(path) if err != nil { - return nil, st.ModTime(), errors.Wrap(err, "open") + return nil, st.ModTime(), fmt.Errorf("open: %w", err) } var events []cloudevents.Event diff --git a/pkg/minikube/cni/bridge.go b/pkg/minikube/cni/bridge.go index d4264920dd..1964c71205 100644 --- a/pkg/minikube/cni/bridge.go +++ b/pkg/minikube/cni/bridge.go @@ -22,7 +22,6 @@ import ( "os/exec" "text/template" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/config" ) @@ -98,11 +97,11 @@ func (c Bridge) Apply(r Runner) error { f, err := c.netconf() if err != nil { - return errors.Wrap(err, "netconf") + return fmt.Errorf("netconf: %w", err) } if err := r.Copy(f); err != nil { - return errors.Wrapf(err, "copy") + return fmt.Errorf("copy: %w", err) } return nil diff --git a/pkg/minikube/cni/calico.go b/pkg/minikube/cni/calico.go index 6f7b55c4b7..d28a811135 100644 --- a/pkg/minikube/cni/calico.go +++ b/pkg/minikube/cni/calico.go @@ -25,7 +25,6 @@ import ( "text/template" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/bootstrapper/images" "k8s.io/minikube/pkg/minikube/config" @@ -84,7 +83,7 @@ func (c Calico) manifest() (assets.CopyableFile, error) { func (c Calico) Apply(r Runner) error { m, err := c.manifest() if err != nil { - return errors.Wrap(err, "manifest") + return fmt.Errorf("manifest: %w", err) } return applyManifest(c.cc, r, m) } diff --git a/pkg/minikube/cni/cilium.go b/pkg/minikube/cni/cilium.go index f02728f6b9..2564355319 100644 --- a/pkg/minikube/cni/cilium.go +++ b/pkg/minikube/cni/cilium.go @@ -26,7 +26,6 @@ import ( "github.com/blang/semver/v4" "github.com/icza/dyno" - "github.com/pkg/errors" "gopkg.in/yaml.v2" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/config" @@ -89,12 +88,12 @@ func (c Cilium) GenerateCiliumYAML() ([]byte, error) { func (c Cilium) Apply(r Runner) error { // see https://kubernetes.io/docs/tasks/administer-cluster/network-policy-provider/cilium-network-policy/ if _, err := r.RunCmd(exec.Command("sudo", "/bin/bash", "-c", "grep 'bpffs /sys/fs/bpf' /proc/mounts || sudo mount bpffs -t bpf /sys/fs/bpf")); err != nil { - return errors.Wrap(err, "bpf mount") + return fmt.Errorf("bpf mount: %w", err) } ciliumCfg, err := c.GenerateCiliumYAML() if err != nil { - return errors.Wrap(err, "generating cilium cfg") + return fmt.Errorf("generating cilium cfg: %w", err) } return applyManifest(c.cc, r, manifestAsset(ciliumCfg)) diff --git a/pkg/minikube/cni/cni.go b/pkg/minikube/cni/cni.go index a8c3147915..6c8c616189 100644 --- a/pkg/minikube/cni/cni.go +++ b/pkg/minikube/cni/cni.go @@ -28,7 +28,6 @@ import ( "time" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/kapi" "k8s.io/minikube/pkg/minikube/assets" @@ -182,12 +181,12 @@ func applyManifest(cc config.ClusterConfig, r Runner, f assets.CopyableFile) err klog.Infof("applying CNI manifest using %s ...", kubectl) if err := r.Copy(f); err != nil { - return errors.Wrapf(err, "copy") + return fmt.Errorf("copy: %w", err) } cmd := exec.CommandContext(ctx, "sudo", kubectl, "apply", fmt.Sprintf("--kubeconfig=%s", path.Join(vmpath.GuestPersistentDir, "kubeconfig")), "-f", manifestPath()) if rr, err := r.RunCmd(cmd); err != nil { - return errors.Wrapf(err, "cmd: %s output: %s", rr.Command(), rr.Output()) + return fmt.Errorf("cmd: %s output: %s: %w", rr.Command(), rr.Output(), err) } return nil diff --git a/pkg/minikube/cni/custom.go b/pkg/minikube/cni/custom.go index b70dfbf9e6..99e2503f6f 100644 --- a/pkg/minikube/cni/custom.go +++ b/pkg/minikube/cni/custom.go @@ -17,10 +17,10 @@ limitations under the License. package cni import ( + "fmt" "os" "path" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/config" @@ -41,7 +41,7 @@ func (c Custom) String() string { func NewCustom(cc config.ClusterConfig, manifest string) (Custom, error) { _, err := os.Stat(manifest) if err != nil { - return Custom{}, errors.Wrap(err, "stat") + return Custom{}, fmt.Errorf("stat: %w", err) } return Custom{ @@ -54,7 +54,7 @@ func NewCustom(cc config.ClusterConfig, manifest string) (Custom, error) { func (c Custom) Apply(r Runner) error { m, err := assets.NewFileAsset(c.manifest, path.Dir(manifestPath()), path.Base(manifestPath()), "0644") if err != nil { - return errors.Wrap(err, "manifest") + return fmt.Errorf("manifest: %w", err) } defer func() { if err := m.Close(); err != nil { diff --git a/pkg/minikube/cni/flannel.go b/pkg/minikube/cni/flannel.go index c906dafd46..cbed369856 100644 --- a/pkg/minikube/cni/flannel.go +++ b/pkg/minikube/cni/flannel.go @@ -19,10 +19,10 @@ package cni import ( "bytes" _ "embed" + "fmt" "os/exec" "text/template" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/config" ) @@ -54,12 +54,12 @@ func (c Flannel) Apply(r Runner) error { // Mostly applicable to the 'none' driver _, err := r.RunCmd(exec.Command("stat", "/opt/cni/bin/portmap")) if err != nil { - return errors.Wrap(err, "required 'portmap' CNI plug-in not found") + return fmt.Errorf("required 'portmap' CNI plug-in not found: %w", err) } m, err := c.manifest() if err != nil { - return errors.Wrap(err, "manifest") + return fmt.Errorf("manifest: %w", err) } return applyManifest(c.cc, r, m) } diff --git a/pkg/minikube/cni/kindnet.go b/pkg/minikube/cni/kindnet.go index 21dc429736..8bee52536e 100644 --- a/pkg/minikube/cni/kindnet.go +++ b/pkg/minikube/cni/kindnet.go @@ -18,10 +18,10 @@ package cni import ( "bytes" + "fmt" "os/exec" "text/template" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/bootstrapper/images" "k8s.io/minikube/pkg/minikube/config" @@ -190,12 +190,12 @@ func (c KindNet) manifest() (assets.CopyableFile, error) { func (c KindNet) Apply(r Runner) error { // This is mostly applicable to the 'none' driver if _, err := r.RunCmd(exec.Command("stat", "/opt/cni/bin/portmap")); err != nil { - return errors.Wrap(err, "required 'portmap' CNI plug-in not found") + return fmt.Errorf("required 'portmap' CNI plug-in not found: %w", err) } m, err := c.manifest() if err != nil { - return errors.Wrap(err, "manifest") + return fmt.Errorf("manifest: %w", err) } return applyManifest(c.cc, r, m) } diff --git a/pkg/minikube/command/command_runner.go b/pkg/minikube/command/command_runner.go index bb8cd6975f..219b47010f 100644 --- a/pkg/minikube/command/command_runner.go +++ b/pkg/minikube/command/command_runner.go @@ -28,7 +28,8 @@ import ( "sync" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/minikube/assets" ) @@ -196,14 +197,14 @@ func fileExists(r Runner, f assets.CopyableFile, dst string) (bool, error) { func writeFile(dst string, f assets.CopyableFile, perms os.FileMode) error { w, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE, perms) if err != nil { - return errors.Wrap(err, "create") + return fmt.Errorf("create: %w", err) } defer w.Close() r := f.(io.Reader) n, err := io.Copy(w, r) if err != nil { - return errors.Wrap(err, "copy") + return fmt.Errorf("copy: %w", err) } if n != int64(f.GetLength()) { @@ -211,7 +212,7 @@ func writeFile(dst string, f assets.CopyableFile, perms os.FileMode) error { } if err := w.Chmod(perms); err != nil { - return errors.Wrap(err, "chmod") + return fmt.Errorf("chmod: %w", err) } return w.Close() diff --git a/pkg/minikube/command/exec_runner.go b/pkg/minikube/command/exec_runner.go index aa395fb118..7453ce233d 100644 --- a/pkg/minikube/command/exec_runner.go +++ b/pkg/minikube/command/exec_runner.go @@ -28,7 +28,6 @@ import ( "strconv" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" ) @@ -115,7 +114,7 @@ func (*execRunner) StartCmd(cmd *exec.Cmd) (*StartedCmd, error) { cmd.Stderr = errb if err := cmd.Start(); err != nil { - return sc, errors.Wrap(err, "start") + return sc, fmt.Errorf("start: %w", err) } return sc, nil @@ -143,7 +142,7 @@ func (e *execRunner) Copy(f assets.CopyableFile) error { if _, err := os.Stat(dst); err == nil { klog.Infof("found %s, removing ...", dst) if err := e.Remove(f); err != nil { - return errors.Wrapf(err, "error removing file %s", dst) + return fmt.Errorf("error removing file %s: %w", dst, err) } } @@ -155,24 +154,24 @@ func (e *execRunner) Copy(f assets.CopyableFile) error { perms, err := strconv.ParseInt(f.GetPermissions(), 8, 0) if err != nil || perms > 07777 { - return errors.Wrapf(err, "error converting permissions %s to integer", f.GetPermissions()) + return fmt.Errorf("error converting permissions %s to integer: %w", f.GetPermissions(), err) } if e.sudo { // write to temp location ... tmpfile, err := os.CreateTemp("", "minikube") if err != nil { - return errors.Wrap(err, "error creating tempfile") + return fmt.Errorf("error creating tempfile: %w", err) } defer os.Remove(tmpfile.Name()) if err := writeFile(tmpfile.Name(), f, os.FileMode(perms)); err != nil { - return errors.Wrapf(err, "error writing to tempfile %s", tmpfile.Name()) + return fmt.Errorf("error writing to tempfile %s: %w", tmpfile.Name(), err) } // ... then use sudo to move to target if _, err := e.RunCmd(exec.Command("sudo", "cp", "-a", tmpfile.Name(), dst)); err != nil { - return errors.Wrapf(err, "error copying tempfile %s to dst %s", tmpfile.Name(), dst) + return fmt.Errorf("error copying tempfile %s to dst %s: %w", tmpfile.Name(), dst, err) } return nil } @@ -191,7 +190,7 @@ func (e *execRunner) CopyFrom(f assets.CopyableFile) error { perms, err := strconv.ParseInt(f.GetPermissions(), 8, 0) if err != nil || perms > 07777 { - return errors.Wrapf(err, "error converting permissions %s to integer", f.GetPermissions()) + return fmt.Errorf("error converting permissions %s to integer: %w", f.GetPermissions(), err) } return writeFile(dst, f, os.FileMode(perms)) diff --git a/pkg/minikube/command/fake_runner.go b/pkg/minikube/command/fake_runner.go index 6a775615a7..526d2144e6 100644 --- a/pkg/minikube/command/fake_runner.go +++ b/pkg/minikube/command/fake_runner.go @@ -26,8 +26,6 @@ import ( "golang.org/x/sync/syncmap" - "github.com/pkg/errors" - "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" ) @@ -76,7 +74,7 @@ func (f *FakeCommandRunner) RunCmd(cmd *exec.Cmd) (*RunResult, error) { } _, err := buf.WriteString(outStr) if err != nil { - return rr, errors.Wrap(err, "Writing outStr to FakeCommandRunner's buffer") + return rr, fmt.Errorf("Writing outStr to FakeCommandRunner's buffer: %w", err) } rr.Stdout = buf rr.Stderr = buf @@ -118,7 +116,7 @@ func (f *FakeCommandRunner) StartCmd(cmd *exec.Cmd) (*StartedCmd, error) { } _, err := buf.WriteString(outStr) if err != nil { - return sc, errors.Wrap(err, "Writing outStr to FakeCommandRunner's buffer") + return sc, fmt.Errorf("Writing outStr to FakeCommandRunner's buffer: %w", err) } rr.Stdout = buf rr.Stderr = buf @@ -136,7 +134,7 @@ func (f *FakeCommandRunner) Copy(file assets.CopyableFile) error { var b bytes.Buffer _, err := io.Copy(&b, file) if err != nil { - return errors.Wrapf(err, "error reading file: %+v", file) + return fmt.Errorf("error reading file: %+v: %w", file, err) } f.fileMap.Store(file.GetSourcePath(), b.String()) return nil @@ -151,7 +149,7 @@ func (f *FakeCommandRunner) CopyFrom(file assets.CopyableFile) error { b := v.(bytes.Buffer) _, err := io.Copy(file, &b) if err != nil { - return errors.Wrapf(err, "error writing file: %+v", file) + return fmt.Errorf("error writing file: %+v: %w", file, err) } return nil } diff --git a/pkg/minikube/command/kic_runner.go b/pkg/minikube/command/kic_runner.go index 980d741b85..33e715f5f8 100644 --- a/pkg/minikube/command/kic_runner.go +++ b/pkg/minikube/command/kic_runner.go @@ -28,7 +28,6 @@ import ( "strings" "time" - "github.com/pkg/errors" "golang.org/x/term" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic/oci" @@ -166,7 +165,7 @@ func (k *kicRunner) Copy(f assets.CopyableFile) error { perms, err := strconv.ParseInt(f.GetPermissions(), 8, 0) if err != nil || perms > 07777 { - return errors.Wrapf(err, "error converting permissions %s to integer", f.GetPermissions()) + return fmt.Errorf("error converting permissions %s to integer: %w", f.GetPermissions(), err) } if src != assets.MemorySource { @@ -192,18 +191,18 @@ func (k *kicRunner) Copy(f assets.CopyableFile) error { tmpFolder, err := tempDirectory(detect.MinikubeInstalledViaSnap(), detect.DockerInstalledViaSnap()) if err != nil { - return errors.Wrap(err, "determining temp directory") + return fmt.Errorf("determining temp directory: %w", err) } tf, err := os.CreateTemp(tmpFolder, "tmpf-memory-asset") if err != nil { - return errors.Wrap(err, "creating temporary file") + return fmt.Errorf("creating temporary file: %w", err) } defer tf.Close() defer os.Remove(tf.Name()) if err := writeFile(tf.Name(), f, os.FileMode(perms)); err != nil { - return errors.Wrap(err, "write") + return fmt.Errorf("write: %w", err) } return k.copy(tf.Name(), dst) } @@ -229,7 +228,7 @@ func tempDirectory(isMinikubeSnap bool, isDockerSnap bool) (string, error) { home, err := os.UserHomeDir() if err != nil { - return "", errors.Wrap(err, "detecting home dir") + return "", fmt.Errorf("detecting home dir: %w", err) } return home, nil } @@ -261,7 +260,7 @@ func copyToPodman(src string, dest string) error { cmd := oci.PrefixCmd(exec.Command(oci.Podman, "cp", src, dest)) klog.Infof("Run: %v", cmd) if out, err := cmd.CombinedOutput(); err != nil { - return errors.Wrapf(err, "podman copy %s into %s, output: %s", src, dest, string(out)) + return fmt.Errorf("podman copy %s into %s, output: %s: %w", src, dest, string(out), err) } } else { file, err := os.Open(src) @@ -276,7 +275,7 @@ func copyToPodman(src string, dest string) error { cmd.Stdin = file klog.Infof("Run: %v", cmd) if err := cmd.Run(); err != nil { - return errors.Wrapf(err, "podman copy %s into %s", src, dest) + return fmt.Errorf("podman copy %s into %s: %w", src, dest, err) } } return nil @@ -284,7 +283,7 @@ func copyToPodman(src string, dest string) error { func copyToDocker(src string, dest string) error { if out, err := oci.PrefixCmd(exec.Command(oci.Docker, "cp", "-a", src, dest)).CombinedOutput(); err != nil { - return errors.Wrapf(err, "docker copy %s into %s, output: %s", src, dest, string(out)) + return fmt.Errorf("docker copy %s into %s, output: %s: %w", src, dest, string(out), err) } return nil } diff --git a/pkg/minikube/command/ssh_runner.go b/pkg/minikube/command/ssh_runner.go index 8736e60cf9..0ab8bf51f0 100644 --- a/pkg/minikube/command/ssh_runner.go +++ b/pkg/minikube/command/ssh_runner.go @@ -29,7 +29,6 @@ import ( "time" "github.com/kballard/go-shellquote" - "github.com/pkg/errors" "golang.org/x/crypto/ssh" "golang.org/x/sync/errgroup" "k8s.io/klog/v2" @@ -109,7 +108,7 @@ func (s *SSHRunner) client() (*ssh.Client, error) { c, err := sshutil.NewSSHClient(s.d) if err != nil { - return nil, errors.Wrap(err, "new client") + return nil, fmt.Errorf("new client: %w", err) } s.c = c return s.c, nil @@ -121,7 +120,7 @@ func (s *SSHRunner) session() (*ssh.Session, error) { getSession := func() (err error) { client, err := s.client() if err != nil { - return errors.Wrap(err, "new client") + return fmt.Errorf("new client: %w", err) } sess, err = client.NewSession() @@ -147,7 +146,7 @@ func (s *SSHRunner) Remove(f assets.CopyableFile) error { sess, err := s.session() if err != nil { - return errors.Wrap(err, "getting ssh session") + return fmt.Errorf("getting ssh session: %w", err) } defer sess.Close() @@ -158,12 +157,12 @@ func (s *SSHRunner) Remove(f assets.CopyableFile) error { func teeSSH(s *ssh.Session, cmd string, outB io.Writer, errB io.Writer) error { outPipe, err := s.StdoutPipe() if err != nil { - return errors.Wrap(err, "stdout") + return fmt.Errorf("stdout: %w", err) } errPipe, err := s.StderrPipe() if err != nil { - return errors.Wrap(err, "stderr") + return fmt.Errorf("stderr: %w", err) } var wg sync.WaitGroup wg.Add(2) @@ -213,7 +212,7 @@ func (s *SSHRunner) RunCmd(cmd *exec.Cmd) (*RunResult, error) { sess, err := s.session() if err != nil { - return rr, errors.Wrap(err, "NewSession") + return rr, fmt.Errorf("NewSession: %w", err) } defer func() { @@ -245,12 +244,12 @@ func (s *SSHRunner) RunCmd(cmd *exec.Cmd) (*RunResult, error) { func teeSSHStart(s *ssh.Session, cmd string, outB io.Writer, errB io.Writer, wg *sync.WaitGroup) error { outPipe, err := s.StdoutPipe() if err != nil { - return errors.Wrap(err, "stdout") + return fmt.Errorf("stdout: %w", err) } errPipe, err := s.StderrPipe() if err != nil { - return errors.Wrap(err, "stderr") + return fmt.Errorf("stderr: %w", err) } go func() { @@ -303,7 +302,7 @@ func (s *SSHRunner) StartCmd(cmd *exec.Cmd) (*StartedCmd, error) { sess, err := s.session() if err != nil { - return sc, errors.Wrap(err, "NewSession") + return sc, fmt.Errorf("NewSession: %w", err) } s.s = sess @@ -366,7 +365,7 @@ func (s *SSHRunner) Copy(f assets.CopyableFile) error { sess, err := s.session() if err != nil { - return errors.Wrap(err, "NewSession") + return fmt.Errorf("NewSession: %w", err) } defer func() { if err := sess.Close(); err != nil { @@ -378,7 +377,7 @@ func (s *SSHRunner) Copy(f assets.CopyableFile) error { w, err := sess.StdinPipe() if err != nil { - return errors.Wrap(err, "StdinPipe") + return fmt.Errorf("StdinPipe: %w", err) } // The scpcmd below *should not* return until all data is copied and the // StdinPipe is closed. But let's use errgroup to make it explicit. @@ -395,7 +394,7 @@ func (s *SSHRunner) Copy(f assets.CopyableFile) error { copied, err := io.Copy(w, f) if err != nil { - return errors.Wrap(err, "io.Copy") + return fmt.Errorf("io.Copy: %w", err) } if copied != int64(f.GetLength()) { return fmt.Errorf("%s: expected to copy %d bytes, but copied %d instead", f.GetTargetName(), f.GetLength(), copied) @@ -425,7 +424,7 @@ func (s *SSHRunner) CopyFrom(f assets.CopyableFile) error { sess, err := s.session() if err != nil { - return errors.Wrap(err, "NewSession") + return fmt.Errorf("NewSession: %w", err) } defer func() { if err := sess.Close(); err != nil { @@ -450,11 +449,11 @@ func (s *SSHRunner) CopyFrom(f assets.CopyableFile) error { r, err := sess.StdoutPipe() if err != nil { - return errors.Wrap(err, "StdoutPipe") + return fmt.Errorf("StdoutPipe: %w", err) } w, err := sess.StdinPipe() if err != nil { - return errors.Wrap(err, "StdinPipe") + return fmt.Errorf("StdinPipe: %w", err) } // The scpcmd below *should not* return until all data is copied and the // StdinPipe is closed. But let's use errgroup to make it explicit. @@ -467,7 +466,7 @@ func (s *SSHRunner) CopyFrom(f assets.CopyableFile) error { fmt.Fprint(w, "\x00") b, err := br.ReadBytes('\n') if err != nil { - return errors.Wrap(err, "ReadBytes") + return fmt.Errorf("ReadBytes: %w", err) } if b[0] != 'C' { return fmt.Errorf("unexpected: %v", b) @@ -478,7 +477,7 @@ func (s *SSHRunner) CopyFrom(f assets.CopyableFile) error { for copied < int64(length) { n, err := io.CopyN(f, br, int64(length)) if err != nil { - return errors.Wrap(err, "io.CopyN") + return fmt.Errorf("io.CopyN: %w", err) } copied += n } @@ -528,12 +527,12 @@ func (s *SSHRunner) ReadableFile(sourcePath string) (assets.ReadableFile, error) sess, err := s.session() if err != nil { - return nil, errors.Wrap(err, "NewSession") + return nil, fmt.Errorf("NewSession: %w", err) } r, err := sess.StdoutPipe() if err != nil { - return nil, errors.Wrap(err, "StdOutPipe") + return nil, fmt.Errorf("StdOutPipe: %w", err) } cmd := fmt.Sprintf("cat %s", sourcePath) diff --git a/pkg/minikube/config/config.go b/pkg/minikube/config/config.go index 1010d1fc13..38c989e4b6 100644 --- a/pkg/minikube/config/config.go +++ b/pkg/minikube/config/config.go @@ -22,7 +22,8 @@ import ( "io" "os" - "github.com/pkg/errors" + "errors" + "github.com/spf13/viper" "k8s.io/klog/v2" @@ -213,7 +214,7 @@ func (c *simpleConfigLoader) LoadConfigFromFile(profileName string, miniHome ... if os.IsNotExist(err) { return nil, &ErrNotExist{fmt.Sprintf("cluster %q does not exist", profileName)} } - return nil, errors.Wrap(err, "stat") + return nil, fmt.Errorf("stat: %w", err) } data, err := os.ReadFile(path) @@ -221,11 +222,11 @@ func (c *simpleConfigLoader) LoadConfigFromFile(profileName string, miniHome ... if os.IsPermission(err) { return nil, &ErrPermissionDenied{err.Error()} } - return nil, errors.Wrap(err, "read") + return nil, fmt.Errorf("read: %w", err) } if err := json.Unmarshal(data, &cc); err != nil { - return nil, errors.Wrap(err, "unmarshal") + return nil, fmt.Errorf("unmarshal: %w", err) } return &cc, nil } diff --git a/pkg/minikube/cruntime/containerd.go b/pkg/minikube/cruntime/containerd.go index 4526a42e01..2fdbece4c4 100644 --- a/pkg/minikube/cruntime/containerd.go +++ b/pkg/minikube/cruntime/containerd.go @@ -31,7 +31,6 @@ import ( "github.com/blang/semver/v4" "github.com/cenkalti/backoff/v5" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/bootstrapper/images" @@ -98,7 +97,7 @@ func (r *Containerd) Version() (string, error) { c := exec.Command("containerd", "--version") rr, err := r.Runner.RunCmd(c) if err != nil { - return "", errors.Wrapf(err, "containerd check version") + return "", fmt.Errorf("containerd check version: %w", err) } version, err := parseContainerdVersion(rr.Stdout.String()) if err != nil { @@ -124,7 +123,7 @@ func (r *Containerd) Active() bool { func (r *Containerd) Available() error { c := exec.Command("which", "containerd") if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "check containerd availability") + return fmt.Errorf("check containerd availability: %w", err) } return checkCNIPlugins(r.KubernetesVersion) } @@ -133,10 +132,10 @@ func (r *Containerd) Available() error { func generateContainerdConfig(cr CommandRunner, imageRepository string, kv semver.Version, cgroupDriver string, insecureRegistry []string, inUserNamespace bool) error { pauseImage := images.Pause(kv, imageRepository) if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i -r 's|^( *)sandbox_image = .*$|\1sandbox_image = %q|' %s`, pauseImage, containerdConfigFile))); err != nil { - return errors.Wrap(err, "update sandbox_image") + return fmt.Errorf("update sandbox_image: %w", err) } if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i -r 's|^( *)restrict_oom_score_adj = .*$|\1restrict_oom_score_adj = %t|' %s`, inUserNamespace, containerdConfigFile))); err != nil { - return errors.Wrap(err, "update restrict_oom_score_adj") + return fmt.Errorf("update restrict_oom_score_adj: %w", err) } // configure cgroup driver @@ -147,26 +146,26 @@ func generateContainerdConfig(cr CommandRunner, imageRepository string, kv semve klog.Infof("configuring containerd to use %q as cgroup driver...", cgroupDriver) useSystemd := cgroupDriver == constants.SystemdCgroupDriver if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i -r 's|^( *)SystemdCgroup = .*$|\1SystemdCgroup = %t|g' %s`, useSystemd, containerdConfigFile))); err != nil { - return errors.Wrap(err, "configuring SystemdCgroup") + return fmt.Errorf("configuring SystemdCgroup: %w", err) } // handle deprecated/removed features // ref: https://github.com/containerd/containerd/blob/main/RELEASES.md#deprecated-features if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i 's|"io.containerd.runtime.v1.linux"|"io.containerd.runc.v2"|g' %s`, containerdConfigFile))); err != nil { - return errors.Wrap(err, "configuring io.containerd.runtime version") + return fmt.Errorf("configuring io.containerd.runtime version: %w", err) } // avoid containerd v1.6.14+ "failed to load plugin io.containerd.grpc.v1.cri" error="invalid plugin config: `systemd_cgroup` only works for runtime io.containerd.runtime.v1.linux" error // that then leads to crictl "getting the runtime version: rpc error: code = Unimplemented desc = unknown service runtime.v1alpha2.RuntimeService" error // ref: https://github.com/containerd/containerd/issues/4203 if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i '/systemd_cgroup/d' %s`, containerdConfigFile))); err != nil { - return errors.Wrap(err, "removing deprecated systemd_cgroup param") + return fmt.Errorf("removing deprecated systemd_cgroup param: %w", err) } // "runtime_type" has to be specified and it should be "io.containerd.runc.v2" // ref: https://github.com/containerd/containerd/issues/6964#issuecomment-1132378279 if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i 's|"io.containerd.runc.v1"|"io.containerd.runc.v2"|g' %s`, containerdConfigFile))); err != nil { - return errors.Wrap(err, "configuring io.containerd.runc version") + return fmt.Errorf("configuring io.containerd.runc version: %w", err) } // ensure conf_dir is using '/etc/cni/net.d' @@ -175,7 +174,7 @@ func generateContainerdConfig(cr CommandRunner, imageRepository string, kv semve klog.Warningf("unable to remove /etc/cni/net.mk directory: %v", err) } if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i -r 's|^( *)conf_dir = .*$|\1conf_dir = %q|g' %s`, cni.DefaultConfDir, containerdConfigFile))); err != nil { - return errors.Wrap(err, "update conf_dir") + return fmt.Errorf("update conf_dir: %w", err) } // enable 'enable_unprivileged_ports' so that containers that run with non-root user can bind to otherwise privilege ports (like coredns v1.11.0+) @@ -185,11 +184,11 @@ func generateContainerdConfig(cr CommandRunner, imageRepository string, kv semve if kv.GTE(semver.Version{Major: 1, Minor: 22}) { // remove any existing 'enable_unprivileged_ports' settings if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i '/^ *enable_unprivileged_ports = .*/d' %s`, containerdConfigFile))); err != nil { - return errors.Wrap(err, "removing enable_unprivileged_ports") + return fmt.Errorf("removing enable_unprivileged_ports: %w", err) } // add 'enable_unprivileged_ports' with value 'true' if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i -r 's|^( *)\[plugins."io.containerd.grpc.v1.cri"\]|&\n\1 enable_unprivileged_ports = true|' %s`, containerdConfigFile))); err != nil { - return errors.Wrap(err, "configuring enable_unprivileged_ports") + return fmt.Errorf("configuring enable_unprivileged_ports: %w", err) } } @@ -204,7 +203,7 @@ func generateContainerdConfig(cr CommandRunner, imageRepository string, kv semve t, err := template.New("hosts.toml").Parse(containerdInsecureRegistryTemplate) if err != nil { - return errors.Wrap(err, "unable to parse insecure registry template") + return fmt.Errorf("unable to parse insecure registry template: %w", err) } opts := struct { InsecureRegistry string @@ -213,13 +212,13 @@ func generateContainerdConfig(cr CommandRunner, imageRepository string, kv semve } var b bytes.Buffer if err := t.Execute(&b, opts); err != nil { - return errors.Wrap(err, "unable to create insecure registry template") + return fmt.Errorf("unable to create insecure registry template: %w", err) } regRootPath := path.Join(containerdMirrorsRoot, addr) c := exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo mkdir -p %s && printf %%s \"%s\" | base64 -d | sudo tee %s", regRootPath, base64.StdEncoding.EncodeToString(b.Bytes()), path.Join(regRootPath, "hosts.toml"))) if _, err := cr.RunCmd(c); err != nil { - return errors.Wrap(err, "unable to generate insecure registry cfg") + return fmt.Errorf("unable to generate insecure registry cfg: %w", err) } } return nil @@ -290,9 +289,9 @@ func (r *Containerd) LoadImage(imagePath string) error { if _, err := r.Runner.RunCmd(c); err != nil { // Only retry on transient "short read" or "unexpected EOF" errors if strings.Contains(err.Error(), "short read") || strings.Contains(err.Error(), "unexpected EOF") { - return errors.Wrapf(err, "ctr images import") + return fmt.Errorf("ctr images import: %w", err) } - return backoff.Permanent(errors.Wrapf(err, "ctr images import")) + return backoff.Permanent(fmt.Errorf("ctr images import: %w", err)) } return nil }, 250*time.Millisecond, 2*time.Minute, 3) @@ -308,7 +307,7 @@ func (r *Containerd) SaveImage(name string, destPath string) error { klog.Infof("Saving image %s: %s", name, destPath) c := exec.Command("sudo", "ctr", "-n=k8s.io", "images", "export", destPath, name) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrapf(err, "ctr images export") + return fmt.Errorf("ctr images export: %w", err) } return nil } @@ -323,7 +322,7 @@ func (r *Containerd) TagImage(source string, target string) error { klog.Infof("Tagging image %s: %s", source, target) c := exec.Command("sudo", "ctr", "-n=k8s.io", "images", "tag", source, target) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrapf(err, "ctr images tag") + return fmt.Errorf("ctr images tag: %w", err) } return nil } @@ -426,7 +425,7 @@ func (r *Containerd) BuildImage(src string, file string, tag string, push bool, c.Stdout = os.Stdout c.Stderr = os.Stderr if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "buildctl build") + return fmt.Errorf("buildctl build: %w", err) } return nil } @@ -436,7 +435,7 @@ func (r *Containerd) PushImage(name string) error { klog.Infof("Pushing image %s", name) c := exec.Command("sudo", "ctr", "-n=k8s.io", "images", "push", name) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrapf(err, "ctr images push") + return fmt.Errorf("ctr images push: %w", err) } return nil } @@ -536,7 +535,7 @@ func (r *Containerd) Preload(cc config.ClusterConfig) error { // If images already exist, return imgs, err := images.Kubeadm(cc.KubernetesConfig.ImageRepository, k8sVersion) if err != nil { - return errors.Wrap(err, "getting images") + return fmt.Errorf("getting images: %w", err) } if containerdImagesPreloaded(r.Runner, imgs) { klog.Info("Images already preloaded, skipping extraction") @@ -556,7 +555,7 @@ func (r *Containerd) Preload(cc config.ClusterConfig) error { // Copy over tarball into host fa, err := assets.NewFileAsset(tarballPath, targetDir, targetName, "0644") if err != nil { - return errors.Wrap(err, "getting file asset") + return fmt.Errorf("getting file asset: %w", err) } defer func() { if err := fa.Close(); err != nil { @@ -566,14 +565,14 @@ func (r *Containerd) Preload(cc config.ClusterConfig) error { t := time.Now() if err := r.Runner.Copy(fa); err != nil { - return errors.Wrap(err, "copying file") + return fmt.Errorf("copying file: %w", err) } klog.Infof("duration metric: took %s to copy over tarball", time.Since(t)) t = time.Now() // extract the tarball to /var in the VM if rr, err := r.Runner.RunCmd(exec.Command("sudo", "tar", "--xattrs", "--xattrs-include", "security.capability", "-I", "lz4", "-C", "/var", "-xf", dest)); err != nil { - return errors.Wrapf(err, "extracting tarball: %s", rr.Output()) + return fmt.Errorf("extracting tarball: %s: %w", rr.Output(), err) } klog.Infof("duration metric: took %s to extract the tarball", time.Since(t)) diff --git a/pkg/minikube/cruntime/cri.go b/pkg/minikube/cruntime/cri.go index 2f23624946..3b85e1cf32 100644 --- a/pkg/minikube/cruntime/cri.go +++ b/pkg/minikube/cruntime/cri.go @@ -29,8 +29,6 @@ import ( "github.com/blang/semver/v4" - "github.com/pkg/errors" - "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/command" "k8s.io/minikube/pkg/util/retry" @@ -86,7 +84,7 @@ func crictlList(cr CommandRunner, root string, o ListContainersOptions) (*comman func listCRIContainers(cr CommandRunner, root string, o ListContainersOptions) ([]string, error) { rr, err := crictlList(cr, root, o) if err != nil { - return nil, errors.Wrap(err, "crictl list") + return nil, fmt.Errorf("crictl list: %w", err) } // Avoid an id named "" @@ -117,7 +115,7 @@ func listCRIContainers(cr CommandRunner, root string, o ListContainersOptions) ( args = append(args, "list", "-f", "json") rr, err = cr.RunCmd(exec.Command("sudo", args...)) if err != nil { - return nil, errors.Wrap(err, "runc") + return nil, fmt.Errorf("runc: %w", err) } content := rr.Stdout.Bytes() klog.Infof("JSON = %s", content) @@ -158,7 +156,7 @@ func pauseCRIContainers(cr CommandRunner, root string, ids []string) error { args := baseArgs args = append(args, id) if _, err := cr.RunCmd(exec.Command("sudo", args...)); err != nil { - return errors.Wrap(err, "runc") + return fmt.Errorf("runc: %w", err) } } return nil @@ -185,7 +183,7 @@ func unpauseCRIContainers(cr CommandRunner, root string, ids []string) error { for _, id := range ids { cargs := append(cargs, id) if _, err := cr.RunCmd(exec.Command("sudo", cargs...)); err != nil { - return errors.Wrap(err, "runc") + return fmt.Errorf("runc: %w", err) } } return nil @@ -202,7 +200,7 @@ func killCRIContainers(cr CommandRunner, ids []string) error { args := append([]string{crictl, "rm", "--force"}, ids...) c := exec.Command("sudo", args...) if _, err := cr.RunCmd(c); err != nil { - return errors.Wrap(err, "crictl") + return fmt.Errorf("crictl: %w", err) } return nil } @@ -215,7 +213,7 @@ func pullCRIImage(cr CommandRunner, name string) error { args := append([]string{crictl, "pull"}, name) c := exec.Command("sudo", args...) if _, err := cr.RunCmd(c); err != nil { - return errors.Wrap(err, "crictl") + return fmt.Errorf("crictl: %w", err) } return nil } @@ -240,7 +238,7 @@ func removeCRIImage(cr CommandRunner, name string, verifyRemoval bool) error { } if !success { - return errors.Wrap(err, "crictl") + return fmt.Errorf("crictl: %w", err) } if !verifyRemoval { @@ -261,7 +259,7 @@ func removeCRIImage(cr CommandRunner, name string, verifyRemoval bool) error { } if err := retry.Expo(checkFunc, 250*time.Millisecond, 10*time.Second); err != nil { - return errors.Wrapf(err, "image %s still exists after removal", name) + return fmt.Errorf("image %s still exists after removal: %w", name, err) } return nil } @@ -281,7 +279,7 @@ func stopCRIContainers(cr CommandRunner, ids []string) error { args := append([]string{crictl, "stop", "--timeout=10"}, ids...) c := exec.Command("sudo", args...) if _, err := cr.RunCmd(c); err != nil { - return errors.Wrap(err, "crictl") + return fmt.Errorf("crictl: %w", err) } return nil } @@ -301,7 +299,7 @@ func populateCRIConfig(cr CommandRunner, socket string) error { } c := exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo mkdir -p %s && printf %%s \"%s\" | sudo tee %s", path.Dir(cPath), b.String(), cPath)) if rr, err := cr.RunCmd(c); err != nil { - return errors.Wrapf(err, "Run: %q", rr.Command()) + return fmt.Errorf("Run: %q: %w", rr.Command(), err) } return nil } @@ -312,7 +310,7 @@ func getCRIInfo(cr CommandRunner) (map[string]interface{}, error) { c := exec.Command("sudo", args...) rr, err := cr.RunCmd(c) if err != nil { - return nil, errors.Wrap(err, "get cri info") + return nil, fmt.Errorf("get cri info: %w", err) } info := rr.Stdout.String() jsonMap := make(map[string]interface{}) @@ -328,7 +326,7 @@ func listCRIImages(cr CommandRunner) ([]ListImage, error) { c := exec.Command("sudo", "crictl", timeoutOverrideFlag, "images", "--output", "json") rr, err := cr.RunCmd(c) if err != nil { - return nil, errors.Wrapf(err, "crictl images") + return nil, fmt.Errorf("crictl images: %w", err) } var jsonImages crictlImages diff --git a/pkg/minikube/cruntime/crio.go b/pkg/minikube/cruntime/crio.go index 5205c6b2fe..5e84307ac9 100644 --- a/pkg/minikube/cruntime/crio.go +++ b/pkg/minikube/cruntime/crio.go @@ -27,7 +27,6 @@ import ( "time" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/bootstrapper/images" @@ -59,7 +58,7 @@ func generateCRIOConfig(cr CommandRunner, imageRepository string, kv semver.Vers klog.Infof("configure cri-o to use %q pause image...", pauseImage) c := exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i 's|^.*pause_image = .*$|pause_image = %q|' %s`, pauseImage, crioConfigFile)) if _, err := cr.RunCmd(c); err != nil { - return errors.Wrap(err, "update pause_image") + return fmt.Errorf("update pause_image: %w", err) } // configure cgroup driver @@ -69,7 +68,7 @@ func generateCRIOConfig(cr CommandRunner, imageRepository string, kv semver.Vers } klog.Infof("configuring cri-o to use %q as cgroup driver...", cgroupDriver) if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i 's|^.*cgroup_manager = .*$|cgroup_manager = %q|' %s`, cgroupDriver, crioConfigFile))); err != nil { - return errors.Wrap(err, "configuring cgroup_manager") + return fmt.Errorf("configuring cgroup_manager: %w", err) } // explicitly set conmon_cgroup to avoid errors like: // - level=fatal msg="Validating runtime config: conmon cgroup should be 'pod' or a systemd slice" @@ -78,10 +77,10 @@ func generateCRIOConfig(cr CommandRunner, imageRepository string, kv semver.Vers // ref: https://github.com/cri-o/cri-o/issues/6047 // ref: https://kubernetes.io/docs/setup/production-environment/container-runtimes/#cgroup-driver if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i '/conmon_cgroup = .*/d' %s`, crioConfigFile))); err != nil { - return errors.Wrap(err, "removing conmon_cgroup") + return fmt.Errorf("removing conmon_cgroup: %w", err) } if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i '/cgroup_manager = .*/a conmon_cgroup = %q' %s`, "pod", crioConfigFile))); err != nil { - return errors.Wrap(err, "configuring conmon_cgroup") + return fmt.Errorf("configuring conmon_cgroup: %w", err) } // we might still want to try removing '/etc/cni/net.mk' in case of upgrade from previous minikube version that had/used it @@ -95,15 +94,15 @@ func generateCRIOConfig(cr CommandRunner, imageRepository string, kv semver.Vers if kv.GTE(semver.Version{Major: 1, Minor: 22}) { // remove any existing 'net.ipv4.ip_unprivileged_port_start' settings if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i '/^ *"net.ipv4.ip_unprivileged_port_start=.*"/d' %s`, crioConfigFile))); err != nil { - return errors.Wrap(err, "removing net.ipv4.ip_unprivileged_port_start") + return fmt.Errorf("removing net.ipv4.ip_unprivileged_port_start: %w", err) } // insert 'default_sysctls' list, if not already present if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo grep -q "^ *default_sysctls" %s || sudo sed -i '/conmon_cgroup = .*/a default_sysctls = \[\n\]' %s`, crioConfigFile, crioConfigFile))); err != nil { - return errors.Wrap(err, "inserting default_sysctls") + return fmt.Errorf("inserting default_sysctls: %w", err) } // add 'net.ipv4.ip_unprivileged_port_start' to 'default_sysctls' list if _, err := cr.RunCmd(exec.Command("sh", "-c", fmt.Sprintf(`sudo sed -i -r 's|^default_sysctls *= *\[|&\n "net.ipv4.ip_unprivileged_port_start=0",|' %s`, crioConfigFile))); err != nil { - return errors.Wrap(err, "configuring net.ipv4.ip_unprivileged_port_start") + return fmt.Errorf("configuring net.ipv4.ip_unprivileged_port_start: %w", err) } } @@ -125,7 +124,7 @@ func (r *CRIO) Version() (string, error) { c := exec.Command("crio", "--version") rr, err := r.Runner.RunCmd(c) if err != nil { - return "", errors.Wrap(err, "crio version") + return "", fmt.Errorf("crio version: %w", err) } // crio version 1.13.0 @@ -146,7 +145,7 @@ func (r *CRIO) SocketPath() string { func (r *CRIO) Available() error { c := exec.Command("which", "crio") if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrapf(err, "check crio available") + return fmt.Errorf("check crio available: %w", err) } return checkCNIPlugins(r.KubernetesVersion) } @@ -171,7 +170,7 @@ func enableIPForwarding(cr CommandRunner) error { } c = exec.Command("sudo", "sh", "-c", "echo 1 > /proc/sys/net/ipv4/ip_forward") if _, err := cr.RunCmd(c); err != nil { - return errors.Wrapf(err, "ip_forward") + return fmt.Errorf("ip_forward: %w", err) } return nil } @@ -192,13 +191,13 @@ Environment="_CRIO_ROOTLESS=1" targetDir := filepath.Dir(target) c := exec.Command("sudo", "mkdir", "-p", targetDir) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrapf(err, "failed to create directory %q", targetDir) + return fmt.Errorf("failed to create directory %q: %w", targetDir, err) } asset := assets.NewMemoryAssetTarget([]byte(content), target, "0644") err := r.Runner.Copy(asset) asset.Close() if err != nil { - return errors.Wrapf(err, "failed to create %q", target) + return fmt.Errorf("failed to create %q: %w", target, err) } } // reload systemd to apply our changes on /etc/systemd @@ -275,7 +274,7 @@ func (r *CRIO) LoadImage(imgPath string) error { klog.Infof("Loading image: %s", imgPath) c := exec.Command("sudo", "podman", "load", "-i", imgPath) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "crio load image") + return fmt.Errorf("crio load image: %w", err) } return nil } @@ -290,7 +289,7 @@ func (r *CRIO) SaveImage(name string, destPath string) error { klog.Infof("Saving image %s: %s", name, destPath) c := exec.Command("sudo", "podman", "save", name, "-o", destPath) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "crio save image") + return fmt.Errorf("crio save image: %w", err) } return nil } @@ -305,7 +304,7 @@ func (r *CRIO) TagImage(source string, target string) error { klog.Infof("Tagging image %s: %s", source, target) c := exec.Command("sudo", "podman", "tag", source, target) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "crio tag image") + return fmt.Errorf("crio tag image: %w", err) } return nil } @@ -332,14 +331,14 @@ func (r *CRIO) BuildImage(src string, file string, tag string, push bool, env [] c.Stdout = os.Stdout c.Stderr = os.Stderr if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "crio build image") + return fmt.Errorf("crio build image: %w", err) } if tag != "" && push { c := exec.Command("sudo", "podman", "push", tag) c.Stdout = os.Stdout c.Stderr = os.Stderr if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "crio push image") + return fmt.Errorf("crio push image: %w", err) } } return nil @@ -350,7 +349,7 @@ func (r *CRIO) PushImage(name string) error { klog.Infof("Pushing image %s", name) c := exec.Command("sudo", "podman", "push", name) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "crio push image") + return fmt.Errorf("crio push image: %w", err) } return nil } @@ -427,7 +426,7 @@ func (r *CRIO) Preload(cc config.ClusterConfig) error { // If images already exist, return imgs, err := images.Kubeadm(cc.KubernetesConfig.ImageRepository, k8sVersion) if err != nil { - return errors.Wrap(err, "getting images") + return fmt.Errorf("getting images: %w", err) } if crioImagesPreloaded(r.Runner, imgs) { klog.Info("Images already preloaded, skipping extraction") @@ -481,7 +480,7 @@ func (r *CRIO) Preload(cc config.ClusterConfig) error { // Copy over tarball into host fa, err := assets.NewFileAsset(tarballPath, targetDir, targetName, "0644") if err != nil { - return errors.Wrap(err, "getting file asset") + return fmt.Errorf("getting file asset: %w", err) } defer func() { if err := fa.Close(); err != nil { @@ -491,14 +490,14 @@ func (r *CRIO) Preload(cc config.ClusterConfig) error { t := time.Now() if err := r.Runner.Copy(fa); err != nil { - return errors.Wrap(err, "copying file") + return fmt.Errorf("copying file: %w", err) } klog.Infof("duration metric: took %s to copy over tarball", time.Since(t)) t = time.Now() // extract the tarball to /var in the VM if rr, err := r.Runner.RunCmd(exec.Command("sudo", "tar", "--xattrs", "--xattrs-include", "security.capability", "-I", "lz4", "-C", "/var", "-xf", dest)); err != nil { - return errors.Wrapf(err, "extracting tarball: %s", rr.Output()) + return fmt.Errorf("extracting tarball: %s: %w", rr.Output(), err) } klog.Infof("duration metric: took %s to extract the tarball", time.Since(t)) diff --git a/pkg/minikube/cruntime/cruntime.go b/pkg/minikube/cruntime/cruntime.go index 8b06f042d9..3d2e1ef5ca 100644 --- a/pkg/minikube/cruntime/cruntime.go +++ b/pkg/minikube/cruntime/cruntime.go @@ -22,8 +22,9 @@ import ( "os/exec" "strings" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/command" @@ -319,7 +320,7 @@ func compatibleWithVersion(runtime, v string) error { func CheckCompatibility(cr Manager) error { v, err := cr.Version() if err != nil { - return errors.Wrap(err, "Failed to check container runtime version") + return fmt.Errorf("Failed to check container runtime version: %w", err) } return compatibleWithVersion(cr.Name(), v) } diff --git a/pkg/minikube/cruntime/cruntime_test.go b/pkg/minikube/cruntime/cruntime_test.go index 7037eaeaeb..1239c96c66 100644 --- a/pkg/minikube/cruntime/cruntime_test.go +++ b/pkg/minikube/cruntime/cruntime_test.go @@ -26,7 +26,6 @@ import ( "github.com/blang/semver/v4" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/command" @@ -218,7 +217,7 @@ func buffer(s string, err error) (*command.RunResult, error) { var buf bytes.Buffer _, err = buf.WriteString(s) if err != nil { - return rr, errors.Wrap(err, "Writing outStr to FakeRunner's buffer") + return rr, fmt.Errorf("Writing outStr to FakeRunner's buffer: %w", err) } rr.Stdout = buf rr.Stderr = buf diff --git a/pkg/minikube/cruntime/docker.go b/pkg/minikube/cruntime/docker.go index 19338dc758..efbad32695 100644 --- a/pkg/minikube/cruntime/docker.go +++ b/pkg/minikube/cruntime/docker.go @@ -29,7 +29,6 @@ import ( "github.com/blang/semver/v4" units "github.com/docker/go-units" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/bootstrapper/images" @@ -268,7 +267,7 @@ func (r *Docker) ListImages(ListImagesOptions) ([]ListImage, error) { c := exec.Command("docker", "images", "--no-trunc", "--format", "{{json .}}") rr, err := r.Runner.RunCmd(c) if err != nil { - return nil, errors.Wrapf(err, "docker images") + return nil, fmt.Errorf("docker images: %w", err) } type dockerImage struct { ID string `json:"ID"` @@ -285,11 +284,11 @@ func (r *Docker) ListImages(ListImagesOptions) ([]ListImage, error) { var jsonImage dockerImage if err := json.Unmarshal([]byte(img), &jsonImage); err != nil { - return nil, errors.Wrap(err, "Image convert problem") + return nil, fmt.Errorf("Image convert problem: %w", err) } size, err := units.FromHumanSize(jsonImage.Size) if err != nil { - return nil, errors.Wrap(err, "Image size convert problem") + return nil, fmt.Errorf("Image size convert problem: %w", err) } repoTag := fmt.Sprintf("%s:%s", jsonImage.Repository, jsonImage.Tag) @@ -308,7 +307,7 @@ func (r *Docker) LoadImage(imgPath string) error { klog.Infof("Loading image: %s", imgPath) c := exec.Command("/bin/bash", "-c", fmt.Sprintf("sudo cat %s | docker load", imgPath)) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "loadimage docker") + return fmt.Errorf("loadimage docker: %w", err) } return nil } @@ -321,7 +320,7 @@ func (r *Docker) PullImage(name string) error { } c := exec.Command("docker", "pull", name) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "pull image docker") + return fmt.Errorf("pull image docker: %w", err) } return nil } @@ -331,7 +330,7 @@ func (r *Docker) SaveImage(name string, imagePath string) error { klog.Infof("Saving image %s: %s", name, imagePath) c := exec.Command("/bin/bash", "-c", fmt.Sprintf("docker save '%s' | sudo tee %s >/dev/null", name, imagePath)) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "saveimage docker") + return fmt.Errorf("saveimage docker: %w", err) } return nil } @@ -344,7 +343,7 @@ func (r *Docker) RemoveImage(name string) error { } c := exec.Command("docker", "rmi", name) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "remove image docker") + return fmt.Errorf("remove image docker: %w", err) } return nil } @@ -354,7 +353,7 @@ func (r *Docker) TagImage(source string, target string) error { klog.Infof("Tagging image %s: %s", source, target) c := exec.Command("docker", "tag", source, target) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "tag image docker") + return fmt.Errorf("tag image docker: %w", err) } return nil } @@ -380,14 +379,14 @@ func (r *Docker) BuildImage(src string, file string, tag string, push bool, env c.Stdout = os.Stdout c.Stderr = os.Stderr if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "buildimage docker") + return fmt.Errorf("buildimage docker: %w", err) } if tag != "" && push { c := exec.Command("docker", "push", tag) c.Stdout = os.Stdout c.Stderr = os.Stderr if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "pushimage docker") + return fmt.Errorf("pushimage docker: %w", err) } } return nil @@ -398,7 +397,7 @@ func (r *Docker) PushImage(name string) error { klog.Infof("Pushing image: %s", name) c := exec.Command("docker", "push", name) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "push image docker") + return fmt.Errorf("push image docker: %w", err) } return nil } @@ -448,7 +447,7 @@ func (r *Docker) ListContainers(o ListContainersOptions) ([]string, error) { args = append(args, fmt.Sprintf("--filter=name=%s", nameFilter), "--format={{.ID}}") rr, err := r.Runner.RunCmd(exec.Command("docker", args...)) if err != nil { - return nil, errors.Wrapf(err, "docker") + return nil, fmt.Errorf("docker: %w", err) } var ids []string for _, line := range strings.Split(rr.Stdout.String(), "\n") { @@ -471,7 +470,7 @@ func (r *Docker) KillContainers(ids []string) error { args := append([]string{"rm", "-f"}, ids...) c := exec.Command("docker", args...) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "killing containers docker") + return fmt.Errorf("killing containers docker: %w", err) } return nil } @@ -488,7 +487,7 @@ func (r *Docker) StopContainers(ids []string) error { args := append([]string{"stop"}, ids...) c := exec.Command("docker", args...) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "docker") + return fmt.Errorf("docker: %w", err) } return nil } @@ -505,7 +504,7 @@ func (r *Docker) PauseContainers(ids []string) error { args := append([]string{"pause"}, ids...) c := exec.Command("docker", args...) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "docker") + return fmt.Errorf("docker: %w", err) } return nil } @@ -522,7 +521,7 @@ func (r *Docker) UnpauseContainers(ids []string) error { args := append([]string{"unpause"}, ids...) c := exec.Command("docker", args...) if _, err := r.Runner.RunCmd(c); err != nil { - return errors.Wrap(err, "docker") + return fmt.Errorf("docker: %w", err) } return nil } @@ -618,7 +617,7 @@ func (r *Docker) Preload(cc config.ClusterConfig) error { // If images already exist, return imgs, err := images.Kubeadm(cc.KubernetesConfig.ImageRepository, k8sVersion) if err != nil { - return errors.Wrap(err, "getting images") + return fmt.Errorf("getting images: %w", err) } if dockerImagesPreloaded(r.Runner, imgs) { klog.Info("Images already preloaded, skipping extraction") @@ -643,7 +642,7 @@ func (r *Docker) Preload(cc config.ClusterConfig) error { // Copy over tarball into host fa, err := assets.NewFileAsset(tarballPath, targetDir, targetName, "0644") if err != nil { - return errors.Wrap(err, "getting file asset") + return fmt.Errorf("getting file asset: %w", err) } defer func() { if err := fa.Close(); err != nil { @@ -653,13 +652,13 @@ func (r *Docker) Preload(cc config.ClusterConfig) error { t := time.Now() if err := r.Runner.Copy(fa); err != nil { - return errors.Wrap(err, "copying file") + return fmt.Errorf("copying file: %w", err) } klog.Infof("duration metric: took %s to copy over tarball", time.Since(t)) // extract the tarball to /var in the VM if rr, err := r.Runner.RunCmd(exec.Command("sudo", "tar", "--xattrs", "--xattrs-include", "security.capability", "-I", "lz4", "-C", "/var", "-xf", dest)); err != nil { - return errors.Wrapf(err, "extracting tarball: %s", rr.Output()) + return fmt.Errorf("extracting tarball: %s: %w", rr.Output(), err) } // remove the tarball in the VM @@ -802,16 +801,16 @@ ExecStart={{.ExecPath}} --container-runtime-endpoint fd:// --pod-infra-container b := bytes.Buffer{} if err := CRIDockerServiceConfTemplate.Execute(&b, opts); err != nil { - return errors.Wrap(err, "failed to execute template") + return fmt.Errorf("failed to execute template: %w", err) } criDockerService := b.Bytes() c := exec.Command("sudo", "mkdir", "-p", path.Dir(CRIDockerServiceConfFile)) if _, err := cr.RunCmd(c); err != nil { - return errors.Wrapf(err, "failed to create directory") + return fmt.Errorf("failed to create directory: %w", err) } svc := assets.NewMemoryAssetTarget(criDockerService, CRIDockerServiceConfFile, "0644") if err := cr.Copy(svc); err != nil { - return errors.Wrap(err, "failed to copy template") + return fmt.Errorf("failed to copy template: %w", err) } return nil } diff --git a/pkg/minikube/download/binary.go b/pkg/minikube/download/binary.go index e67c0b0e60..ba20c86e06 100644 --- a/pkg/minikube/download/binary.go +++ b/pkg/minikube/download/binary.go @@ -23,7 +23,6 @@ import ( "runtime" "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/localpath" @@ -82,12 +81,12 @@ func Binary(binary, version, osName, archName, binaryURL string) (string, error) } if err := download(url, targetFilepath); err != nil { - return "", errors.Wrapf(err, "download failed: %s", url) + return "", fmt.Errorf("download failed: %s: %w", url, err) } if osName == runtime.GOOS && archName == runtime.GOARCH { if err = os.Chmod(targetFilepath, 0755); err != nil { - return "", errors.Wrapf(err, "chmod +x %s", targetFilepath) + return "", fmt.Errorf("chmod +x %s: %w", targetFilepath, err) } } return targetFilepath, nil diff --git a/pkg/minikube/download/download.go b/pkg/minikube/download/download.go index 3d4647311c..409711c5d9 100644 --- a/pkg/minikube/download/download.go +++ b/pkg/minikube/download/download.go @@ -26,7 +26,6 @@ import ( "github.com/hashicorp/go-getter" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/detect" "k8s.io/minikube/pkg/minikube/out" @@ -57,7 +56,7 @@ func SetAliyunMirror() { // CreateDstDownloadMock is the default mock implementation of download. func CreateDstDownloadMock(_, dst string) error { if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil { - return errors.Wrap(err, "mkdir") + return fmt.Errorf("mkdir: %w", err) } f, err := os.Create(dst) @@ -98,7 +97,7 @@ func download(src, dst string, options ...getter.ClientOption) error { } if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { - return errors.Wrap(err, "mkdir") + return fmt.Errorf("mkdir: %w", err) } if DownloadMock != nil { @@ -113,7 +112,7 @@ func download(src, dst string, options ...getter.ClientOption) error { klog.Infof("Downloading: %s -> %s", src, dst) if err := client.Get(); err != nil { - return errors.Wrapf(err, "getter: %+v", client) + return fmt.Errorf("getter: %+v: %w", client, err) } return os.Rename(tmpDst, dst) } @@ -141,7 +140,7 @@ func lockDownload(file string) (lock.Releaser, error) { spec.Timeout = 5 * time.Minute releaser, err := lock.Acquire(spec) if err != nil { - lockChannel <- retPair{nil, errors.Wrapf(err, "failed to acquire lock \"%s\": %+v", file, spec)} + lockChannel <- retPair{nil, fmt.Errorf("failed to acquire lock \"%s\": %+v: %w", file, spec, err)} return } lockChannel <- retPair{releaser, err} diff --git a/pkg/minikube/download/driver.go b/pkg/minikube/download/driver.go index eaac58d654..162faa7c4d 100644 --- a/pkg/minikube/download/driver.go +++ b/pkg/minikube/download/driver.go @@ -22,7 +22,6 @@ import ( "runtime" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/out" "k8s.io/minikube/pkg/minikube/style" @@ -45,7 +44,7 @@ func Driver(name string, destination string, v semver.Version) error { if err := download(archURL, destination); err != nil { klog.Infof("failed to download arch specific driver: %v. trying to get the common version", err) if err := download(driverWithChecksumURL(name, v), destination); err != nil { - return errors.Wrap(err, "download") + return fmt.Errorf("download: %w", err) } } diff --git a/pkg/minikube/download/image.go b/pkg/minikube/download/image.go index 290ac9af9c..989d08fb9b 100644 --- a/pkg/minikube/download/image.go +++ b/pkg/minikube/download/image.go @@ -26,6 +26,8 @@ import ( "strings" "time" + "errors" + "github.com/cheggaaa/pb/v3" "github.com/google/go-containerregistry/pkg/name" v1 "github.com/google/go-containerregistry/pkg/v1" @@ -33,7 +35,6 @@ import ( "github.com/google/go-containerregistry/pkg/v1/remote" "github.com/google/go-containerregistry/pkg/v1/tarball" "github.com/hashicorp/go-getter" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/detect" "k8s.io/minikube/pkg/minikube/image" @@ -139,7 +140,7 @@ func ImageToCache(img string) error { } if err := os.MkdirAll(filepath.Dir(f), 0777); err != nil { - return errors.Wrapf(err, "making cache image directory: %s", f) + return fmt.Errorf("making cache image directory: %s: %w", f, err) } if DownloadMock != nil { @@ -150,11 +151,11 @@ func ImageToCache(img string) error { klog.Infof("Writing %s to local cache", img) ref, err := name.ParseReference(img) if err != nil { - return errors.Wrap(err, "parsing reference") + return fmt.Errorf("parsing reference: %w", err) } tag, err := name.NewTag(image.Tag(img)) if err != nil { - return errors.Wrap(err, "parsing tag") + return fmt.Errorf("parsing tag: %w", err) } klog.V(3).Infof("Getting image %v", ref) i, err := remote.Image(ref, remote.WithPlatform(defaultPlatform)) @@ -167,7 +168,7 @@ func ImageToCache(img string) error { return ErrNeedsLogin } - return errors.Wrap(err, "getting remote image") + return fmt.Errorf("getting remote image: %w", err) } klog.V(3).Infof("Writing image %v", tag) errchan := make(chan error) @@ -219,7 +220,7 @@ func ImageToCache(img string) error { p.Finish() } if err != nil { - return errors.Wrap(err, "writing tarball image") + return fmt.Errorf("writing tarball image: %w", err) } return nil } @@ -260,13 +261,13 @@ func parseImage(img string) (*name.Tag, name.Reference, error) { var ref name.Reference tag, err := name.NewTag(image.Tag(img)) if err != nil { - return nil, nil, errors.Wrap(err, "failed to parse image reference") + return nil, nil, fmt.Errorf("failed to parse image reference: %w", err) } digest, err := name.NewDigest(img) if err != nil { _, ok := err.(*name.ErrBadName) if !ok { - return nil, nil, errors.Wrap(err, "new ref") + return nil, nil, fmt.Errorf("new ref: %w", err) } // ErrBadName means img contains no digest // It happens if its value is name:tag for example. @@ -297,7 +298,7 @@ func CacheToDaemon(img string) (string, error) { i, err := tarball.ImageFromPath(p, tag) if err != nil { - return "", errors.Wrap(err, "tarball") + return "", fmt.Errorf("tarball: %w", err) } resp, err := daemon.Write(*tag, i) diff --git a/pkg/minikube/download/iso.go b/pkg/minikube/download/iso.go index 1fc1ad9ea6..548bd9b20b 100644 --- a/pkg/minikube/download/iso.go +++ b/pkg/minikube/download/iso.go @@ -26,7 +26,8 @@ import ( "strings" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/detect" "k8s.io/minikube/pkg/minikube/out" @@ -106,7 +107,7 @@ func ISO(urls []string, skipChecksum bool) (string, error) { func downloadISO(isoURL string, skipChecksum bool) error { u, err := url.Parse(isoURL) if err != nil { - return errors.Wrapf(err, "url.parse %q", isoURL) + return fmt.Errorf("url.parse %q: %w", isoURL, err) } // It's already downloaded @@ -117,14 +118,14 @@ func downloadISO(isoURL string, skipChecksum bool) error { // Lock before we check for existence to avoid thundering herd issues dst := localISOPath(u) if err := os.MkdirAll(filepath.Dir(dst), 0777); err != nil { - return errors.Wrapf(err, "making cache image directory: %s", dst) + return fmt.Errorf("making cache image directory: %s: %w", dst, err) } spec := lock.PathMutexSpec(dst) spec.Timeout = 10 * time.Minute klog.Infof("acquiring lock: %+v", spec) releaser, err := lock.Acquire(spec) if err != nil { - return errors.Wrapf(err, "unable to acquire lock for %+v", spec) + return fmt.Errorf("unable to acquire lock for %+v: %w", spec, err) } defer releaser.Release() diff --git a/pkg/minikube/download/preload.go b/pkg/minikube/download/preload.go index 9f745f4a36..26426ef473 100644 --- a/pkg/minikube/download/preload.go +++ b/pkg/minikube/download/preload.go @@ -30,7 +30,6 @@ import ( "cloud.google.com/go/storage" "google.golang.org/api/option" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/download/gh" @@ -277,18 +276,18 @@ func Preload(k8sVersion, containerRuntime, driverName string) error { realPath = targetPath tmp, err := os.CreateTemp(targetDir(), TarballName(k8sVersion, containerRuntime)+".*") if err != nil { - return errors.Wrap(err, "tempfile") + return fmt.Errorf("tempfile: %w", err) } targetPath = tmp.Name() if err := tmp.Close(); err != nil { - return errors.Wrap(err, "tempfile close") + return fmt.Errorf("tempfile close: %w", err) } } else if checksum != nil { // add URL parameter for go-getter to automatically verify the checksum url = addChecksumToURL(url, source, checksum) } if err := download(url, targetPath); err != nil { - return errors.Wrapf(err, "download failed: %s", url) + return fmt.Errorf("download failed: %s: %w", url, err) } // to avoid partial/corrupt files in final dest. only rename tmp if download didn't error out. @@ -296,7 +295,7 @@ func Preload(k8sVersion, containerRuntime, driverName string) error { klog.Infof("renaming tempfile to %s ...", TarballName(k8sVersion, containerRuntime)) err := os.Rename(targetPath, realPath) if err != nil { - return errors.Wrap(err, "rename") + return fmt.Errorf("rename: %w", err) } } @@ -322,11 +321,11 @@ func getStorageAttrs(name string) (*storage.ObjectAttrs, error) { ctx := context.Background() client, err := storage.NewClient(ctx, option.WithoutAuthentication()) if err != nil { - return nil, errors.Wrap(err, "getting storage client") + return nil, fmt.Errorf("getting storage client: %w", err) } attrs, err := client.Bucket(PreloadBucket).Object(name).Attrs(ctx) if err != nil { - return nil, errors.Wrap(err, "getting storage object") + return nil, fmt.Errorf("getting storage object: %w", err) } return attrs, nil } diff --git a/pkg/minikube/driver/auxdriver/install.go b/pkg/minikube/driver/auxdriver/install.go index fc9266715c..a4d33f029b 100644 --- a/pkg/minikube/driver/auxdriver/install.go +++ b/pkg/minikube/driver/auxdriver/install.go @@ -26,7 +26,6 @@ import ( "time" "github.com/blang/semver/v4" - "github.com/pkg/errors" "k8s.io/klog/v2" @@ -62,7 +61,7 @@ func InstallOrUpdate(name string, directory string, interactive bool, autoUpdate v, err := semver.Make("1.37.0") out.WarningT("Hyperkit driver will be removed in the next minikube release, we have other drivers that work on macOS such as docker or qemu, vfkit. Please consider switching to one of them. For more information, please visit: https://minikube.sigs.k8s.io/docs/drivers/hyperkit/") if err != nil { - return errors.Wrap(err, "can't parse version") + return fmt.Errorf("can't parse version: %w", err) } executable := fmt.Sprintf("docker-machine-driver-%s", name) @@ -73,7 +72,7 @@ func InstallOrUpdate(name string, directory string, interactive bool, autoUpdate klog.Infof("acquiring lock: %+v", spec) releaser, err := lock.Acquire(spec) if err != nil { - return errors.Wrapf(err, "unable to acquire lock for %+v", spec) + return fmt.Errorf("unable to acquire lock for %+v: %w", spec, err) } defer releaser.Release() @@ -134,7 +133,7 @@ func fixDriverPermissions(name string, path string, interactive bool) error { klog.Infof("running: %v", c.Args) err := c.Run() if err != nil { - return errors.Wrapf(err, "%v", c.Args) + return fmt.Errorf("%v: %w", c.Args, err) } } return nil @@ -165,7 +164,7 @@ func validateDriver(executable string, v semver.Version) (string, error) { driverVersion, err := semver.Make(ev) if err != nil { - return path, errors.Wrap(err, "can't parse driver version") + return path, fmt.Errorf("can't parse driver version: %w", err) } klog.Infof("%s version is %s", path, driverVersion) diff --git a/pkg/minikube/driver/driver_windows.go b/pkg/minikube/driver/driver_windows.go index 255d28a0f3..3204f8608b 100644 --- a/pkg/minikube/driver/driver_windows.go +++ b/pkg/minikube/driver/driver_windows.go @@ -22,7 +22,8 @@ import ( "os/exec" "path/filepath" - "github.com/pkg/errors" + "errors" + "golang.org/x/sys/windows/registry" ) diff --git a/pkg/minikube/extract/extract.go b/pkg/minikube/extract/extract.go index 9dbb6e6b01..812092b8e9 100644 --- a/pkg/minikube/extract/extract.go +++ b/pkg/minikube/extract/extract.go @@ -29,8 +29,6 @@ import ( "slices" "strconv" "strings" - - "github.com/pkg/errors" ) // exclude is a list of strings to explicitly omit from translation files. @@ -98,7 +96,7 @@ func newExtractor(functionsToCheck []string) (*state, error) { // Functions must be of the form "package.function" t2 := strings.Split(t, ".") if len(t2) < 2 { - return nil, errors.Errorf("invalid function string %s. Needs package name as well", t) + return nil, fmt.Errorf("invalid function string %s. Needs package name as well", t) } f := funcType{ pack: t2[0], @@ -128,7 +126,7 @@ func TranslatableStrings(paths []string, functions []string, output string) erro e, err := newExtractor(functions) if err != nil { - return errors.Wrap(err, "Initializing") + return fmt.Errorf("Initializing: %w", err) } fmt.Println("Compiling translation strings...") @@ -148,7 +146,7 @@ func TranslatableStrings(paths []string, functions []string, output string) erro }) if err != nil { - return errors.Wrap(err, "Extracting strings") + return fmt.Errorf("Extracting strings: %w", err) } } } @@ -156,7 +154,7 @@ func TranslatableStrings(paths []string, functions []string, output string) erro err = writeStringsToFiles(e, output) if err != nil { - return errors.Wrap(err, "Writing translation files") + return fmt.Errorf("Writing translation files: %w", err) } fmt.Println("Done!") @@ -453,7 +451,7 @@ func checkBinaryExpression(b *ast.BinaryExpr) string { func writeStringsToFiles(e *state, output string) error { err := filepath.Walk(output, func(path string, info os.FileInfo, err error) error { if err != nil { - return errors.Wrap(err, "accessing path") + return fmt.Errorf("accessing path: %w", err) } if info.Mode().IsDir() { return nil @@ -465,13 +463,13 @@ func writeStringsToFiles(e *state, output string) error { currentTranslations := make(map[string]interface{}) f, err := os.ReadFile(path) if err != nil { - return errors.Wrap(err, "reading translation file") + return fmt.Errorf("reading translation file: %w", err) } // Unmarshal nonempty files if len(f) > 0 { err = json.Unmarshal(f, ¤tTranslations) if err != nil { - return errors.Wrap(err, "unmarshalling current translations") + return fmt.Errorf("unmarshalling current translations: %w", err) } } @@ -494,12 +492,12 @@ func writeStringsToFiles(e *state, output string) error { c, err := json.MarshalIndent(currentTranslations, "", "\t") if err != nil { - return errors.Wrap(err, "marshalling translations") + return fmt.Errorf("marshalling translations: %w", err) } c = append(c, '\n') err = os.WriteFile(path, c, info.Mode()) if err != nil { - return errors.Wrap(err, "writing translation file") + return fmt.Errorf("writing translation file: %w", err) } fmt.Printf(" (%d translated, %d untranslated)\n", t, u) @@ -512,12 +510,12 @@ func writeStringsToFiles(e *state, output string) error { c, err := json.MarshalIndent(e.translations, "", "\t") if err != nil { - return errors.Wrap(err, "marshalling translations") + return fmt.Errorf("marshalling translations: %w", err) } path := filepath.Join(output, "strings.txt") err = os.WriteFile(path, c, 0644) if err != nil { - return errors.Wrap(err, "writing translation file") + return fmt.Errorf("writing translation file: %w", err) } return nil diff --git a/pkg/minikube/image/cache.go b/pkg/minikube/image/cache.go index efb08c1797..ec53e43f6f 100644 --- a/pkg/minikube/image/cache.go +++ b/pkg/minikube/image/cache.go @@ -17,14 +17,16 @@ limitations under the License. package image import ( + "fmt" "os" "path/filepath" "time" + "errors" + "github.com/google/go-containerregistry/pkg/name" v1 "github.com/google/go-containerregistry/pkg/v1" "github.com/google/go-containerregistry/pkg/v1/tarball" - "github.com/pkg/errors" "golang.org/x/sync/errgroup" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/detect" @@ -74,14 +76,14 @@ func SaveToDir(images []string, cacheDir string, overwrite bool) error { out.WarningT("The image '{{.imageName}}' was not found; unable to add it to cache.", out.V{"imageName": image}) return nil } - return errors.Wrapf(err, "caching image %q", dst) + return fmt.Errorf("caching image %q: %w", dst, err) } klog.Infof("save to tar file %s -> %s succeeded", image, dst) return nil }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "caching images") + return fmt.Errorf("caching images: %w", err) } klog.Infoln("Successfully saved all images to host disk.") return nil @@ -98,7 +100,7 @@ func saveToTarFile(iname, rawDest string, overwrite bool) error { // OS-specific mangling of destination path dst, err := localpath.DstPath(rawDest) if err != nil { - return errors.Wrap(err, "getting destination path") + return fmt.Errorf("getting destination path: %w", err) } spec := lock.PathMutexSpec(dst) @@ -106,7 +108,7 @@ func saveToTarFile(iname, rawDest string, overwrite bool) error { klog.Infof("acquiring lock: %+v", spec) releaser, err := lock.Acquire(spec) if err != nil { - return errors.Wrapf(err, "unable to acquire lock for %+v", spec) + return fmt.Errorf("unable to acquire lock for %+v: %w", spec, err) } defer releaser.Release() @@ -116,16 +118,16 @@ func saveToTarFile(iname, rawDest string, overwrite bool) error { } if err := os.MkdirAll(filepath.Dir(dst), 0777); err != nil { - return errors.Wrapf(err, "making cache image directory: %s", dst) + return fmt.Errorf("making cache image directory: %s: %w", dst, err) } // use given short name ref, err := name.ParseReference(iname, name.WeakValidation) if err != nil { - return errors.Wrapf(err, "parsing image ref name for %s", iname) + return fmt.Errorf("parsing image ref name for %s: %w", iname, err) } if ref == nil { - return errors.Wrapf(err, "nil reference for %s", iname) + return fmt.Errorf("nil reference for %s: %w", iname, err) } img, cname, err := retrieveImage(ref, iname) @@ -134,17 +136,17 @@ func saveToTarFile(iname, rawDest string, overwrite bool) error { return errCacheImageDoesntExist } if img == nil { - return errors.Wrapf(err, "nil image for %s", iname) + return fmt.Errorf("nil image for %s: %w", iname, err) } if cname != iname { // use new canonical name ref, err = name.ParseReference(cname, name.WeakValidation) if err != nil { - return errors.Wrapf(err, "parsing image ref name for %s", cname) + return fmt.Errorf("parsing image ref name for %s: %w", cname, err) } if ref == nil { - return errors.Wrapf(err, "nil reference for %s", cname) + return fmt.Errorf("nil reference for %s: %w", cname, err) } } @@ -176,15 +178,15 @@ func writeImage(img v1.Image, dst string, ref name.Reference) error { err = tarball.Write(ref, img, f) if err != nil { - return errors.Wrap(err, "write") + return fmt.Errorf("write: %w", err) } err = f.Close() if err != nil { - return errors.Wrap(err, "close") + return fmt.Errorf("close: %w", err) } err = os.Rename(f.Name(), dst) if err != nil { - return errors.Wrap(err, "rename") + return fmt.Errorf("rename: %w", err) } return nil } diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go index 3a1e0a1c0d..b7c1e1c095 100644 --- a/pkg/minikube/image/image.go +++ b/pkg/minikube/image/image.go @@ -36,7 +36,8 @@ import ( "github.com/google/go-containerregistry/pkg/v1/remote" "github.com/google/go-containerregistry/pkg/v1/tarball" - "github.com/pkg/errors" + "errors" + "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/detect" "k8s.io/minikube/pkg/minikube/localpath" @@ -278,7 +279,7 @@ func imageFromPathWithRetry(path string, tag name.Tag) (v1.Image, error) { if err == nil { return img, nil } - lastErr = errors.Wrap(err, "tarball") + lastErr = fmt.Errorf("tarball: %w", err) if !isRetryableEOF(err) { return nil, lastErr } @@ -332,7 +333,7 @@ func fixPlatform(ref name.Reference, img v1.Image, p v1.Platform) (v1.Image, err img, err = mutate.ConfigFile(img, cfg) if err != nil { klog.Warningf("failed to change config for %s: %v", ref, err) - return img, errors.Wrap(err, "failed to change image config") + return img, fmt.Errorf("failed to change image config: %w", err) } return img, nil } diff --git a/pkg/minikube/kubeconfig/context.go b/pkg/minikube/kubeconfig/context.go index 9436aab438..61e1c77dd3 100644 --- a/pkg/minikube/kubeconfig/context.go +++ b/pkg/minikube/kubeconfig/context.go @@ -17,7 +17,8 @@ limitations under the License. package kubeconfig import ( - "github.com/pkg/errors" + "fmt" + "k8s.io/client-go/tools/clientcmd/api" "k8s.io/klog/v2" ) @@ -30,14 +31,14 @@ func UnsetCurrentContext(machineName string, configPath ...string) error { } cfg, err := readOrNew(fPath) if err != nil { - return errors.Wrap(err, "Error getting kubeconfig status") + return fmt.Errorf("Error getting kubeconfig status: %w", err) } // Unset current-context only if profile is the current-context if cfg.CurrentContext == machineName { cfg.CurrentContext = "" if err := writeToFile(cfg, fPath); err != nil { - return errors.Wrap(err, "writing kubeconfig") + return fmt.Errorf("writing kubeconfig: %w", err) } return nil } @@ -53,7 +54,7 @@ func GetCurrentContext(configPath ...string) (string, error) { } kcfg, err := readOrNew(fPath) if err != nil { - return "", errors.Wrap(err, "Error getting kubeconfig status") + return "", fmt.Errorf("Error getting kubeconfig status: %w", err) } return kcfg.CurrentContext, err @@ -67,7 +68,7 @@ func SetCurrentContext(name string, configPath ...string) error { } kcfg, err := readOrNew(fPath) if err != nil { - return errors.Wrap(err, "Error getting kubeconfig status") + return fmt.Errorf("Error getting kubeconfig status: %w", err) } kcfg.CurrentContext = name return writeToFile(kcfg, fPath) @@ -81,7 +82,7 @@ func DeleteContext(machineName string, configPath ...string) error { } kcfg, err := readOrNew(fPath) if err != nil { - return errors.Wrap(err, "Error getting kubeconfig status") + return fmt.Errorf("Error getting kubeconfig status: %w", err) } if kcfg == nil || api.IsConfigEmpty(kcfg) { @@ -98,7 +99,7 @@ func DeleteContext(machineName string, configPath ...string) error { } if err := writeToFile(kcfg, fPath); err != nil { - return errors.Wrap(err, "writing kubeconfig") + return fmt.Errorf("writing kubeconfig: %w", err) } return nil } diff --git a/pkg/minikube/kubeconfig/kubeconfig.go b/pkg/minikube/kubeconfig/kubeconfig.go index 5ed754ea24..3c34d86973 100644 --- a/pkg/minikube/kubeconfig/kubeconfig.go +++ b/pkg/minikube/kubeconfig/kubeconfig.go @@ -24,7 +24,6 @@ import ( "path/filepath" "strconv" - "github.com/pkg/errors" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/tools/clientcmd/api" "k8s.io/client-go/tools/clientcmd/api/latest" @@ -49,7 +48,7 @@ func UpdateEndpoint(contextName string, host string, port int, configPath string cfg, err := readOrNew(configPath) if err != nil { - return false, errors.Wrap(err, "get kubeconfig") + return false, fmt.Errorf("get kubeconfig: %w", err) } address := "https://" + host + ":" + strconv.Itoa(port) @@ -73,12 +72,12 @@ func UpdateEndpoint(contextName string, host string, port int, configPath string kcs.ExtensionCluster = ext } if err = PopulateFromSettings(kcs, cfg); err != nil { - return false, errors.Wrap(err, "populate kubeconfig") + return false, fmt.Errorf("populate kubeconfig: %w", err) } err = writeToFile(cfg, configPath) if err != nil { - return false, errors.Wrap(err, "write kubeconfig") + return false, fmt.Errorf("write kubeconfig: %w", err) } return true, nil @@ -96,7 +95,7 @@ func VerifyEndpoint(contextName string, host string, port int, configPath string gotHost, gotPort, err := Endpoint(contextName, configPath) if err != nil { - return errors.Wrap(err, "get endpoint") + return fmt.Errorf("get endpoint: %w", err) } if host != gotHost || port != gotPort { @@ -114,23 +113,23 @@ func Endpoint(contextName string, configPath string) (string, int, error) { apiCfg, err := readOrNew(configPath) if err != nil { - return "", 0, errors.Wrap(err, "read kubeconfig") + return "", 0, fmt.Errorf("read kubeconfig: %w", err) } cluster, ok := apiCfg.Clusters[contextName] if !ok { - return "", 0, errors.Errorf("%q does not appear in %s", contextName, configPath) + return "", 0, fmt.Errorf("%q does not appear in %s", contextName, configPath) } klog.Infof("found %q server: %q", contextName, cluster.Server) u, err := url.Parse(cluster.Server) if err != nil { - return "", 0, errors.Wrap(err, "url parse") + return "", 0, fmt.Errorf("url parse: %w", err) } port, err := strconv.Atoi(u.Port()) if err != nil { - return "", 0, errors.Wrap(err, "atoi") + return "", 0, fmt.Errorf("atoi: %w", err) } return u.Hostname(), port, nil @@ -140,13 +139,13 @@ func Endpoint(contextName string, configPath string) (string, int, error) { func configIssues(cfg *api.Config, contextName string, address string) []error { errs := []error{} if _, ok := cfg.Clusters[contextName]; !ok { - errs = append(errs, errors.Errorf("kubeconfig missing %q cluster setting", contextName)) + errs = append(errs, fmt.Errorf("kubeconfig missing %q cluster setting", contextName)) } else if cfg.Clusters[contextName].Server != address { - errs = append(errs, errors.Errorf("kubeconfig needs server address update")) + errs = append(errs, fmt.Errorf("kubeconfig needs server address update")) } if _, ok := cfg.Contexts[contextName]; !ok { - errs = append(errs, errors.Errorf("kubeconfig missing %q context setting", contextName)) + errs = append(errs, fmt.Errorf("kubeconfig missing %q context setting", contextName)) } if len(errs) > 0 { @@ -187,13 +186,13 @@ func readOrNew(configPath string) (*api.Config, error) { return api.NewConfig(), nil } if err != nil { - return nil, errors.Wrapf(err, "read kubeconfig from %q", configPath) + return nil, fmt.Errorf("read kubeconfig from %q: %w", configPath, err) } // decode config, empty if no bytes kcfg, err := decode(data) if err != nil { - return nil, errors.Wrapf(err, "decode kubeconfig from %q", configPath) + return nil, fmt.Errorf("decode kubeconfig from %q: %w", configPath, err) } // initialize nil maps @@ -220,7 +219,7 @@ func decode(data []byte) (*api.Config, error) { kcfg, _, err := latest.Codec.Decode(data, nil, nil) if err != nil { - return nil, errors.Wrapf(err, "decode data: %s", string(data)) + return nil, fmt.Errorf("decode data: %s: %w", string(data), err) } return kcfg.(*api.Config), nil @@ -240,24 +239,24 @@ func writeToFile(config runtime.Object, configPath string) error { // encode config to YAML data, err := runtime.Encode(latest.Codec, config) if err != nil { - return errors.Errorf("could not write to '%s': failed to encode config: %v", configPath, err) + return fmt.Errorf("could not write to '%s': failed to encode config: %v", configPath, err) } // create parent dir if doesn't exist dir := filepath.Dir(configPath) if _, err := os.Stat(dir); os.IsNotExist(err) { if err = os.MkdirAll(dir, 0755); err != nil { - return errors.Wrapf(err, "Error creating directory: %s", dir) + return fmt.Errorf("Error creating directory: %s: %w", dir, err) } } // write with restricted permissions if err := lock.WriteFile(configPath, data, 0600); err != nil { - return errors.Wrapf(err, "Error writing file %s", configPath) + return fmt.Errorf("Error writing file %s: %w", configPath, err) } if err := pkgutil.MaybeChownDirRecursiveToMinikubeUser(dir); err != nil { - return errors.Wrapf(err, "Error recursively changing ownership for dir: %s", dir) + return fmt.Errorf("Error recursively changing ownership for dir: %s: %w", dir, err) } return nil diff --git a/pkg/minikube/kubeconfig/settings.go b/pkg/minikube/kubeconfig/settings.go index 1bc79217a1..3e31b84b3f 100644 --- a/pkg/minikube/kubeconfig/settings.go +++ b/pkg/minikube/kubeconfig/settings.go @@ -17,11 +17,11 @@ limitations under the License. package kubeconfig import ( + "fmt" "os" "path/filepath" "sync/atomic" - "github.com/pkg/errors" "k8s.io/apimachinery/pkg/runtime" "k8s.io/client-go/tools/clientcmd/api" "k8s.io/klog/v2" @@ -84,7 +84,7 @@ func PopulateFromSettings(cfg *Settings, apiCfg *api.Config) error { if cfg.EmbedCerts { cluster.CertificateAuthorityData, err = os.ReadFile(cfg.CertificateAuthority) if err != nil { - return errors.Wrapf(err, "reading CertificateAuthority %s", cfg.CertificateAuthority) + return fmt.Errorf("reading CertificateAuthority %s: %w", cfg.CertificateAuthority, err) } } else { cluster.CertificateAuthority = cfg.CertificateAuthority @@ -101,11 +101,11 @@ func PopulateFromSettings(cfg *Settings, apiCfg *api.Config) error { if cfg.EmbedCerts { user.ClientCertificateData, err = os.ReadFile(cfg.ClientCertificate) if err != nil { - return errors.Wrapf(err, "reading ClientCertificate %s", cfg.ClientCertificate) + return fmt.Errorf("reading ClientCertificate %s: %w", cfg.ClientCertificate, err) } user.ClientKeyData, err = os.ReadFile(cfg.ClientKey) if err != nil { - return errors.Wrapf(err, "reading ClientKey %s", cfg.ClientKey) + return fmt.Errorf("reading ClientKey %s: %w", cfg.ClientKey, err) } } else { user.ClientCertificate = cfg.ClientCertificate @@ -141,7 +141,7 @@ func Update(kcs *Settings) error { klog.Infof("acquiring lock: %+v", spec) releaser, err := lock.Acquire(spec) if err != nil { - return errors.Wrapf(err, "unable to acquire lock for %+v", spec) + return fmt.Errorf("unable to acquire lock for %+v: %w", spec, err) } defer releaser.Release() @@ -162,7 +162,7 @@ func Update(kcs *Settings) error { // write back to disk if err := writeToFile(kcfg, kcs.filePath()); err != nil { - return errors.Wrap(err, "writing kubeconfig") + return fmt.Errorf("writing kubeconfig: %w", err) } return nil } diff --git a/pkg/minikube/localpath/localpath.go b/pkg/minikube/localpath/localpath.go index 6a7cd27509..d38abfcb64 100644 --- a/pkg/minikube/localpath/localpath.go +++ b/pkg/minikube/localpath/localpath.go @@ -27,7 +27,6 @@ import ( "strings" "github.com/otiai10/copy" - "github.com/pkg/errors" "k8s.io/client-go/util/homedir" "k8s.io/klog/v2" ) @@ -174,7 +173,7 @@ func DstPath(dst string) (string, error) { // Therefore, will replace the drive letter to a volume name. var err error if dst, err = replaceWinDriveLetterToVolumeName(dst); err != nil { - return "", errors.Wrap(err, "parsing docker archive dst ref: replace a Win drive letter to a volume name") + return "", fmt.Errorf("parsing docker archive dst ref: replace a Win drive letter to a volume name: %w", err) } } return dst, nil diff --git a/pkg/minikube/logs/logs.go b/pkg/minikube/logs/logs.go index f9cc5dd7ed..2f2a481fae 100644 --- a/pkg/minikube/logs/logs.go +++ b/pkg/minikube/logs/logs.go @@ -28,7 +28,6 @@ import ( "sort" "strings" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/audit" @@ -105,7 +104,7 @@ func Follow(r cruntime.Manager, bs bootstrapper.Bootstrapper, cfg config.Cluster cmd.Stdout = logOutput cmd.Stderr = logOutput if _, err := cr.RunCmd(cmd); err != nil { - return errors.Wrapf(err, "log follow") + return fmt.Errorf("log follow: %w", err) } return nil } diff --git a/pkg/minikube/machine/advice.go b/pkg/minikube/machine/advice.go index 19157ed4e1..7bcc0b2a21 100644 --- a/pkg/minikube/machine/advice.go +++ b/pkg/minikube/machine/advice.go @@ -19,7 +19,8 @@ package machine import ( "runtime" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/minikube/out" "k8s.io/minikube/pkg/minikube/style" diff --git a/pkg/minikube/machine/build_images.go b/pkg/minikube/machine/build_images.go index 7d4c6e68e7..8eabeba867 100644 --- a/pkg/minikube/machine/build_images.go +++ b/pkg/minikube/machine/build_images.go @@ -17,6 +17,7 @@ limitations under the License. package machine import ( + "fmt" "net/url" "os" "os/exec" @@ -27,7 +28,6 @@ import ( dockerref "github.com/distribution/reference" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine/state" "k8s.io/minikube/pkg/minikube/assets" @@ -46,7 +46,7 @@ var buildRoot = path.Join(vmpath.GuestPersistentDir, "build") func BuildImage(srcPath string, file string, tag string, push bool, env []string, opt []string, profiles []*config.Profile, allNodes bool, nodeName string, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "api") + return fmt.Errorf("api: %w", err) } defer api.Close() @@ -65,7 +65,7 @@ func BuildImage(srcPath string, file string, tag string, push bool, env []string if tag != "" { named, err := dockerref.ParseNormalizedNamed(tag) if err != nil { - return errors.Wrapf(err, "couldn't parse image reference %q", tag) + return fmt.Errorf("couldn't parse image reference %q: %w", tag, err) } tag = named.String() } @@ -140,13 +140,13 @@ func BuildImage(srcPath string, file string, tag string, push bool, env []string func buildImage(cr command.Runner, k8s config.KubernetesConfig, src string, file string, tag string, push bool, env []string, opt []string) error { r, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: cr}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } klog.Infof("Building image from url: %s", src) err = r.BuildImage(src, file, tag, push, env, opt) if err != nil { - return errors.Wrapf(err, "%s build %s", r.Name(), src) + return fmt.Errorf("%s build %s: %w", r.Name(), src, err) } klog.Infof("Built %s from %s", tag, src) @@ -157,7 +157,7 @@ func buildImage(cr command.Runner, k8s config.KubernetesConfig, src string, file func transferAndBuildImage(cr command.Runner, k8s config.KubernetesConfig, src string, file string, tag string, push bool, env []string, opt []string) error { r, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: cr}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } klog.Infof("Building image from path: %s", src) @@ -176,7 +176,7 @@ func transferAndBuildImage(cr command.Runner, k8s config.KubernetesConfig, src s dst := path.Join(buildRoot, filename) f, err := assets.NewFileAsset(src, buildRoot, filename, "0644") if err != nil { - return errors.Wrapf(err, "creating copyable file asset: %s", filename) + return fmt.Errorf("creating copyable file asset: %s: %w", filename, err) } defer func() { if err := f.Close(); err != nil { @@ -185,7 +185,7 @@ func transferAndBuildImage(cr command.Runner, k8s config.KubernetesConfig, src s }() if err := cr.Copy(f); err != nil { - return errors.Wrap(err, "transferring cached image") + return fmt.Errorf("transferring cached image: %w", err) } context := path.Join(buildRoot, ".", strings.TrimSuffix(filename, filepath.Ext(filename))) @@ -203,7 +203,7 @@ func transferAndBuildImage(cr command.Runner, k8s config.KubernetesConfig, src s } err = r.BuildImage(context, file, tag, push, env, opt) if err != nil { - return errors.Wrapf(err, "%s build %s", r.Name(), dst) + return fmt.Errorf("%s build %s: %w", r.Name(), dst, err) } args = append([]string{"rm", "-rf"}, context) diff --git a/pkg/minikube/machine/cache_binaries.go b/pkg/minikube/machine/cache_binaries.go index c2bd5de04f..80aa39849f 100644 --- a/pkg/minikube/machine/cache_binaries.go +++ b/pkg/minikube/machine/cache_binaries.go @@ -17,9 +17,9 @@ limitations under the License. package machine import ( + "fmt" "runtime" - "github.com/pkg/errors" "golang.org/x/sync/errgroup" "k8s.io/minikube/pkg/minikube/bootstrapper" "k8s.io/minikube/pkg/minikube/download" @@ -50,7 +50,7 @@ func CacheBinariesForBootstrapper(version string, excludeBinaries []string, bina bin := bin // https://go.dev/doc/faq#closures_and_goroutines g.Go(func() error { if _, err := download.Binary(bin, version, "linux", runtime.GOARCH, binariesURL); err != nil { - return errors.Wrapf(err, "caching binary %s", bin) + return fmt.Errorf("caching binary %s: %w", bin, err) } return nil }) diff --git a/pkg/minikube/machine/cache_images.go b/pkg/minikube/machine/cache_images.go index 3be6edf02e..93ccfae033 100644 --- a/pkg/minikube/machine/cache_images.go +++ b/pkg/minikube/machine/cache_images.go @@ -33,7 +33,6 @@ import ( "github.com/docker/go-units" "github.com/olekukonko/tablewriter" "github.com/olekukonko/tablewriter/tw" - "github.com/pkg/errors" "golang.org/x/sync/errgroup" "gopkg.in/yaml.v2" "k8s.io/klog/v2" @@ -64,11 +63,11 @@ var saveRoot = path.Join(vmpath.GuestPersistentDir, "images") func CacheImagesForBootstrapper(imageRepository, version string) error { images, err := bootstrapper.GetCachedImageList(imageRepository, version) if err != nil { - return errors.Wrap(err, "cached images list") + return fmt.Errorf("cached images list: %w", err) } if err := image.SaveToDir(images, detect.ImageCacheDir(), false); err != nil { - return errors.Wrap(err, "Caching images") + return fmt.Errorf("Caching images: %w", err) } return nil @@ -78,7 +77,7 @@ func CacheImagesForBootstrapper(imageRepository, version string) error { func LoadCachedImages(cc *config.ClusterConfig, runner command.Runner, imgs []string, cacheDir string, overwrite bool) error { cr, err := cruntime.New(cruntime.Config{Type: cc.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } // Skip loading images if images already exist @@ -120,7 +119,7 @@ func LoadCachedImages(cc *config.ClusterConfig, runner command.Runner, imgs []st }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "LoadCachedImages") + return fmt.Errorf("LoadCachedImages: %w", err) } klog.Infoln("Successfully loaded all cached images") return nil @@ -181,7 +180,7 @@ func LoadLocalImages(cc *config.ClusterConfig, runner command.Runner, images []s }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "loading images") + return fmt.Errorf("loading images: %w", err) } klog.Infoln("Successfully loaded all images") return nil @@ -195,7 +194,7 @@ func CacheAndLoadImages(images []string, profiles []*config.Profile, overwrite b // This is the most important thing if err := image.SaveToDir(images, detect.ImageCacheDir(), overwrite); err != nil { - return errors.Wrap(err, "save to dir") + return fmt.Errorf("save to dir: %w", err) } return DoLoadImages(images, profiles, detect.ImageCacheDir(), overwrite, options) @@ -205,7 +204,7 @@ func CacheAndLoadImages(images []string, profiles []*config.Profile, overwrite b func DoLoadImages(images []string, profiles []*config.Profile, cacheDir string, overwrite bool, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "api") + return fmt.Errorf("api: %w", err) } defer api.Close() @@ -281,7 +280,7 @@ func transferAndLoadCachedImage(cr command.Runner, k8s config.KubernetesConfig, func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, src string, imgName string) error { r, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: cr}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } if err := removeExistingImage(r, src, imgName); err != nil { @@ -297,7 +296,7 @@ func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, src st dst := path.Join(loadRoot, filename) f, err := assets.NewFileAsset(src, loadRoot, filename, "0644") if err != nil { - return errors.Wrapf(err, "creating copyable file asset: %s", filename) + return fmt.Errorf("creating copyable file asset: %s: %w", filename, err) } defer func() { if err := f.Close(); err != nil { @@ -306,7 +305,7 @@ func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, src st }() if err := cr.Copy(f); err != nil { - return errors.Wrap(err, "transferring cached image") + return fmt.Errorf("transferring cached image: %w", err) } loadImageLock.Lock() @@ -317,7 +316,7 @@ func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, src st if strings.Contains(err.Error(), "ctr: image might be filtered out") { out.WarningT("The image '{{.imageName}}' does not match arch of the container runtime, use a multi-arch image instead", out.V{"imageName": imgName}) } - return errors.Wrapf(err, "%s load %s", r.Name(), dst) + return fmt.Errorf("%s load %s: %w", r.Name(), dst, err) } klog.Infof("Transferred and loaded %s from cache", src) @@ -338,7 +337,7 @@ func removeExistingImage(r cruntime.Manager, src string, imgName string) error { errStr := strings.ToLower(err.Error()) if !strings.Contains(errStr, "no such image") && !strings.Contains(errStr, "unable to remove the image") { - return errors.Wrap(err, "removing image") + return fmt.Errorf("removing image: %w", err) } return nil @@ -362,7 +361,7 @@ func SaveCachedImages(cc *config.ClusterConfig, runner command.Runner, images [] }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "saving cached images") + return fmt.Errorf("saving cached images: %w", err) } klog.Infoln("Successfully saved all cached images") return nil @@ -378,7 +377,7 @@ func SaveLocalImages(cc *config.ClusterConfig, runner command.Runner, images []s }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "saving images") + return fmt.Errorf("saving images: %w", err) } klog.Infoln("Successfully saved all images") return nil @@ -397,7 +396,7 @@ func SaveAndCacheImages(images []string, profiles []*config.Profile, options *ru func DoSaveImages(images []string, output string, profiles []*config.Profile, cacheDir string, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "api") + return fmt.Errorf("api: %w", err) } defer api.Close() @@ -472,7 +471,7 @@ func transferAndSaveCachedImage(cr command.Runner, k8s config.KubernetesConfig, func transferAndSaveImage(cr command.Runner, k8s config.KubernetesConfig, dst string, imgName string) error { r, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: cr}) if err != nil { - return errors.Wrap(err, "runtime") + return fmt.Errorf("runtime: %w", err) } found := false // the reason why we are doing this is that @@ -502,7 +501,7 @@ func transferAndSaveImage(cr command.Runner, k8s config.KubernetesConfig, dst st f, err := assets.NewFileAsset(dst, saveRoot, filename, "0644") if err != nil { - return errors.Wrapf(err, "creating copyable file asset: %s", filename) + return fmt.Errorf("creating copyable file asset: %s: %w", filename, err) } defer func() { if err := f.Close(); err != nil { @@ -517,11 +516,11 @@ func transferAndSaveImage(cr command.Runner, k8s config.KubernetesConfig, dst st } err = r.SaveImage(imgName, src) if err != nil { - return errors.Wrapf(err, "%s save %s", r.Name(), src) + return fmt.Errorf("%s save %s: %w", r.Name(), src, err) } if err := cr.CopyFrom(f); err != nil { - return errors.Wrap(err, "transferring cached image") + return fmt.Errorf("transferring cached image: %w", err) } klog.Infof("Transferred and saved %s to cache", dst) @@ -546,7 +545,7 @@ func pullImages(crMgr cruntime.Manager, imgs []string) error { }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "error pulling images") + return fmt.Errorf("error pulling images: %w", err) } klog.Infoln("Successfully pulled images") return nil @@ -556,7 +555,7 @@ func pullImages(crMgr cruntime.Manager, imgs []string) error { func PullImages(images []string, profile *config.Profile, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "error creating api client") + return fmt.Errorf("error creating api client: %w", err) } defer api.Close() @@ -568,7 +567,7 @@ func PullImages(images []string, profile *config.Profile, options *run.CommandOp c, err := config.Load(pName) if err != nil { klog.Errorf("Failed to load profile %q: %v", pName, err) - return errors.Wrapf(err, "error loading config for profile :%v", pName) + return fmt.Errorf("error loading config for profile :%v: %w", pName, err) } for _, n := range c.Nodes { @@ -592,7 +591,7 @@ func PullImages(images []string, profile *config.Profile, options *run.CommandOp } crMgr, err := cruntime.New(cruntime.Config{Type: c.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { - return errors.Wrap(err, "error creating container runtime") + return fmt.Errorf("error creating container runtime: %w", err) } err = pullImages(crMgr, images) if err != nil { @@ -627,7 +626,7 @@ func removeImages(crMgr cruntime.Manager, imgs []string) error { }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "error removing images") + return fmt.Errorf("error removing images: %w", err) } klog.Infoln("Successfully removed images") return nil @@ -637,7 +636,7 @@ func removeImages(crMgr cruntime.Manager, imgs []string) error { func RemoveImages(images []string, profile *config.Profile, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "error creating api client") + return fmt.Errorf("error creating api client: %w", err) } defer api.Close() @@ -649,7 +648,7 @@ func RemoveImages(images []string, profile *config.Profile, options *run.Command c, err := config.Load(pName) if err != nil { klog.Errorf("Failed to load profile %q: %v", pName, err) - return errors.Wrapf(err, "error loading config for profile :%v", pName) + return fmt.Errorf("error loading config for profile :%v: %w", pName, err) } for _, n := range c.Nodes { @@ -673,7 +672,7 @@ func RemoveImages(images []string, profile *config.Profile, options *run.Command } crMgr, err := cruntime.New(cruntime.Config{Type: c.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { - return errors.Wrap(err, "error creating container runtime") + return fmt.Errorf("error creating container runtime: %w", err) } err = removeImages(crMgr, images) if err != nil { @@ -695,7 +694,7 @@ func RemoveImages(images []string, profile *config.Profile, options *run.Command func ListImages(profile *config.Profile, format string, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "error creating api client") + return fmt.Errorf("error creating api client: %w", err) } defer api.Close() @@ -704,7 +703,7 @@ func ListImages(profile *config.Profile, format string, options *run.CommandOpti c, err := config.Load(pName) if err != nil { klog.Errorf("Failed to load profile %q: %v", pName, err) - return errors.Wrapf(err, "error loading config for profile :%v", pName) + return fmt.Errorf("error loading config for profile :%v: %w", pName, err) } imageListsFromNodes := [][]cruntime.ListImage{} @@ -729,7 +728,7 @@ func ListImages(profile *config.Profile, format string, options *run.CommandOpti } cr, err := cruntime.New(cruntime.Config{Type: c.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { - return errors.Wrap(err, "error creating container runtime") + return fmt.Errorf("error creating container runtime: %w", err) } list, err := cr.ListImages(cruntime.ListImagesOptions{}) if err != nil { @@ -864,7 +863,7 @@ func renderImagesTable(images [][]string) { func TagImage(profile *config.Profile, source string, target string, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "error creating api client") + return fmt.Errorf("error creating api client: %w", err) } defer api.Close() @@ -876,7 +875,7 @@ func TagImage(profile *config.Profile, source string, target string, options *ru c, err := config.Load(pName) if err != nil { klog.Errorf("Failed to load profile %q: %v", pName, err) - return errors.Wrapf(err, "error loading config for profile :%v", pName) + return fmt.Errorf("error loading config for profile :%v: %w", pName, err) } for _, n := range c.Nodes { @@ -900,7 +899,7 @@ func TagImage(profile *config.Profile, source string, target string, options *ru } crMgr, err := cruntime.New(cruntime.Config{Type: c.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { - return errors.Wrap(err, "error creating container runtime") + return fmt.Errorf("error creating container runtime: %w", err) } err = crMgr.TagImage(source, target) if err != nil { @@ -935,7 +934,7 @@ func pushImages(crMgr cruntime.Manager, imgs []string) error { }) } if err := g.Wait(); err != nil { - return errors.Wrap(err, "error pushing images") + return fmt.Errorf("error pushing images: %w", err) } klog.Infoln("Successfully pushed images") return nil @@ -945,7 +944,7 @@ func pushImages(crMgr cruntime.Manager, imgs []string) error { func PushImages(images []string, profile *config.Profile, options *run.CommandOptions) error { api, err := NewAPIClient(options) if err != nil { - return errors.Wrap(err, "error creating api client") + return fmt.Errorf("error creating api client: %w", err) } defer api.Close() @@ -957,7 +956,7 @@ func PushImages(images []string, profile *config.Profile, options *run.CommandOp c, err := config.Load(pName) if err != nil { klog.Errorf("Failed to load profile %q: %v", pName, err) - return errors.Wrapf(err, "error loading config for profile :%v", pName) + return fmt.Errorf("error loading config for profile :%v: %w", pName, err) } for _, n := range c.Nodes { @@ -981,7 +980,7 @@ func PushImages(images []string, profile *config.Profile, options *run.CommandOp } crMgr, err := cruntime.New(cruntime.Config{Type: c.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { - return errors.Wrap(err, "error creating container runtime") + return fmt.Errorf("error creating container runtime: %w", err) } err = pushImages(crMgr, images) if err != nil { diff --git a/pkg/minikube/machine/client.go b/pkg/minikube/machine/client.go index 7b451aec3c..d636935e77 100644 --- a/pkg/minikube/machine/client.go +++ b/pkg/minikube/machine/client.go @@ -26,7 +26,6 @@ import ( "time" "github.com/gofrs/flock" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/auth" @@ -104,7 +103,7 @@ func (api *LocalClient) NewHost(drvName string, rawDriver []byte) (*host.Host, e d := def.Init(api.commandOptions) err := json.Unmarshal(rawDriver, d) if err != nil { - return nil, errors.Wrapf(err, "Error getting driver %s", string(rawDriver)) + return nil, fmt.Errorf("Error getting driver %s: %w", string(rawDriver), err) } return &host.Host{ @@ -135,7 +134,7 @@ func (api *LocalClient) NewHost(drvName string, rawDriver []byte) (*host.Host, e func (api *LocalClient) Load(name string) (*host.Host, error) { h, err := api.Filestore.Load(name) if err != nil { - return nil, errors.Wrapf(err, "filestore %q", name) + return nil, fmt.Errorf("filestore %q: %w", name, err) } def := registry.Driver(h.DriverName) @@ -233,7 +232,7 @@ func (api *LocalClient) Create(h *host.Host) error { for _, step := range steps { if err := step.f(); err != nil { - return errors.Wrap(err, step.name) + return fmt.Errorf("%s: %w", step.name, err) } } diff --git a/pkg/minikube/machine/delete.go b/pkg/minikube/machine/delete.go index 3877a2eaa5..cd27fa3e4b 100644 --- a/pkg/minikube/machine/delete.go +++ b/pkg/minikube/machine/delete.go @@ -18,10 +18,10 @@ package machine import ( "context" + "fmt" "os/exec" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/libmachine" @@ -108,12 +108,12 @@ func deleteHost(api libmachine.API, h *host.Host, machineName string) error { nerr := h.Driver.Remove() if nerr != nil { - return errors.Wrap(nerr, "host remove retry") + return fmt.Errorf("host remove retry: %w", nerr) } } if err := api.Remove(machineName); err != nil { - return errors.Wrap(err, "api remove") + return fmt.Errorf("api remove: %w", err) } return nil } diff --git a/pkg/minikube/machine/filesync.go b/pkg/minikube/machine/filesync.go index cd4bfdaf26..18999cde8f 100644 --- a/pkg/minikube/machine/filesync.go +++ b/pkg/minikube/machine/filesync.go @@ -23,7 +23,6 @@ import ( "path" "path/filepath" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/command" @@ -92,12 +91,12 @@ func syncLocalAssets(cr command.Runner) error { func localAssets() ([]assets.CopyableFile, error) { fs, err := assetsFromDir(localpath.MakeMiniPath("addons"), vmpath.GuestAddonsDir, true) if err != nil { - return fs, errors.Wrap(err, "addons dir") + return fs, fmt.Errorf("addons dir: %w", err) } localFiles, err := assetsFromDir(localpath.MakeMiniPath("files"), "/", false) if err != nil { - return fs, errors.Wrap(err, "files dir") + return fs, fmt.Errorf("files dir: %w", err) } fs = append(fs, localFiles...) @@ -149,7 +148,7 @@ func assetsFromDir(localRoot string, destRoot string, flatten bool) ([]assets.Co klog.Infof("local asset: %s -> %s in %s", localPath, targetName, targetDir) f, err := assets.NewFileAsset(localPath, targetDir, targetName, ps) if err != nil { - return errors.Wrapf(err, "creating file asset for %s", localPath) + return fmt.Errorf("creating file asset for %s: %w", localPath, err) } fs = append(fs, f) return nil diff --git a/pkg/minikube/machine/fix.go b/pkg/minikube/machine/fix.go index d2811e24ba..a097d82c69 100644 --- a/pkg/minikube/machine/fix.go +++ b/pkg/minikube/machine/fix.go @@ -24,7 +24,6 @@ import ( "strings" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/host" @@ -58,7 +57,7 @@ func fixHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*hos h, err := api.Load(config.MachineName(*cc, *n)) if err != nil { - return h, errors.Wrap(err, "error loading existing host. Please try running [minikube delete], then run [minikube start] again") + return h, fmt.Errorf("error loading existing host. Please try running [minikube delete], then run [minikube start] again: %w", err) } defer postStartValidations(h, cc.Driver) @@ -78,7 +77,7 @@ func fixHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*hos h.HostOptions.EngineOptions.Env = e.Env err = provisionDockerMachine(h) if err != nil { - return h, errors.Wrap(err, "provision") + return h, fmt.Errorf("provision: %w", err) } } @@ -87,7 +86,7 @@ func fixHost(api libmachine.API, cc *config.ClusterConfig, n *config.Node) (*hos } if err := postStartSetup(h, *cc); err != nil { - return h, errors.Wrap(err, "post-start") + return h, fmt.Errorf("post-start: %w", err) } // on vm node restart and for ha (multi-control plane) topology only (for now), @@ -126,7 +125,7 @@ func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.No h, err = createHost(api, cc, n) if err != nil { - return nil, errors.Wrap(err, "recreate") + return nil, fmt.Errorf("recreate: %w", err) } recreated = true @@ -151,7 +150,7 @@ func recreateIfNeeded(api libmachine.API, cc *config.ClusterConfig, n *config.No } if err := h.Driver.Start(); err != nil { MaybeDisplayAdvice(err, h.DriverName) - return h, errors.Wrap(err, "driver start") + return h, fmt.Errorf("driver start: %w", err) } if err := saveHost(api, h, cc, n); err != nil { return h, err @@ -201,7 +200,7 @@ func ensureSyncedGuestClock(h hostRunner, drv string) error { return nil } if err := adjustGuestClock(h, time.Now()); err != nil { - return errors.Wrap(err, "adjusting system clock") + return fmt.Errorf("adjusting system clock: %w", err) } return nil } @@ -211,17 +210,17 @@ func ensureSyncedGuestClock(h hostRunner, drv string) error { func guestClockDelta(h hostRunner, local time.Time) (time.Duration, error) { rest, err := h.RunSSHCommand("date +%s.%N") if err != nil { - return 0, errors.Wrap(err, "get clock") + return 0, fmt.Errorf("get clock: %w", err) } klog.Infof("guest clock: %s", rest) ns := strings.Split(strings.TrimSpace(rest), ".") secs, err := strconv.ParseInt(strings.TrimSpace(ns[0]), 10, 64) if err != nil { - return 0, errors.Wrap(err, "atoi") + return 0, fmt.Errorf("atoi: %w", err) } nsecs, err := strconv.ParseInt(strings.TrimSpace(ns[1]), 10, 64) if err != nil { - return 0, errors.Wrap(err, "atoi") + return 0, fmt.Errorf("atoi: %w", err) } // NOTE: In a synced state, remote is a few hundred ms ahead of local remote := time.Unix(secs, nsecs) diff --git a/pkg/minikube/machine/host.go b/pkg/minikube/machine/host.go index 07240e83f2..26b76f1f64 100644 --- a/pkg/minikube/machine/host.go +++ b/pkg/minikube/machine/host.go @@ -17,7 +17,8 @@ limitations under the License. package machine import ( - "github.com/pkg/errors" + "fmt" + "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/host" "k8s.io/minikube/pkg/libmachine/state" @@ -29,7 +30,7 @@ import ( func Status(api libmachine.API, machineName string) (string, error) { exists, err := api.Exists(machineName) if err != nil { - return "", errors.Wrapf(err, "%s exists", machineName) + return "", fmt.Errorf("%s exists: %w", machineName, err) } if !exists { return state.None.String(), nil @@ -37,12 +38,12 @@ func Status(api libmachine.API, machineName string) (string, error) { hostInfo, err := api.Load(machineName) if err != nil { - return "", errors.Wrapf(err, "load") + return "", fmt.Errorf("load: %w", err) } s, err := hostInfo.Driver.GetState() if err != nil { - return "", errors.Wrap(err, "state") + return "", fmt.Errorf("state: %w", err) } return s.String(), nil } @@ -66,15 +67,15 @@ func LoadHost(api libmachine.API, machineName string) (*host.Host, error) { klog.Infof("Checking if %q exists ...", machineName) exists, err := api.Exists(machineName) if err != nil { - return nil, errors.Wrapf(err, "Error checking that machine exists: %s", machineName) + return nil, fmt.Errorf("Error checking that machine exists: %s: %w", machineName, err) } if !exists { - return nil, errors.Errorf("machine %q does not exist", machineName) + return nil, fmt.Errorf("machine %q does not exist", machineName) } h, err := api.Load(machineName) if err != nil { - return nil, errors.Wrapf(err, "loading machine %q", machineName) + return nil, fmt.Errorf("loading machine %q: %w", machineName, err) } return h, nil } diff --git a/pkg/minikube/machine/machine.go b/pkg/minikube/machine/machine.go index aa64a34411..7846cd8f01 100644 --- a/pkg/minikube/machine/machine.go +++ b/pkg/minikube/machine/machine.go @@ -17,12 +17,14 @@ limitations under the License. package machine import ( + "fmt" "os/exec" "path" "strings" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/host" @@ -99,7 +101,7 @@ func provisionDockerMachine(h *host.Host) error { p, err := fastDetectProvisioner(h) if err != nil { - return errors.Wrap(err, "fast detect") + return fmt.Errorf("fast detect: %w", err) } // avoid costly need to stop/power off/delete and then re-create docker machine due to the un-ready ssh server and hence errors like: @@ -135,7 +137,7 @@ func fastDetectProvisioner(h *host.Host) (libprovision.Provisioner, error) { // saveHost is a wrapper around libmachine's Save function to proactively update the node's IP whenever a host is saved func saveHost(api libmachine.API, h *host.Host, cfg *config.ClusterConfig, n *config.Node) error { if err := api.Save(h); err != nil { - return errors.Wrap(err, "save") + return fmt.Errorf("save: %w", err) } // Save IP to config file for subsequent use @@ -158,22 +160,22 @@ func backup(h host.Host, files []string) error { r, err := CommandRunner(&h) if err != nil { - return errors.Wrap(err, "command runner") + return fmt.Errorf("command runner: %w", err) } // ensure target dir exists if _, err := r.RunCmd(exec.Command("sudo", "mkdir", "-p", vmpath.GuestBackupDir)); err != nil { - return errors.Wrapf(err, "create dir") + return fmt.Errorf("create dir: %w", err) } errs := []error{} for _, src := range []string{"/etc/cni", "/etc/kubernetes"} { if _, err := r.RunCmd(exec.Command("sudo", "rsync", "--archive", "--relative", src, vmpath.GuestBackupDir)); err != nil { - errs = append(errs, errors.Errorf("failed to copy %q to %q (will continue): %v", src, vmpath.GuestBackupDir, err)) + errs = append(errs, fmt.Errorf("failed to copy %q to %q (will continue): %v", src, vmpath.GuestBackupDir, err)) } } if len(errs) > 0 { - return errors.Errorf("%v", errs) + return fmt.Errorf("%v", errs) } return nil } @@ -185,13 +187,13 @@ func backup(h host.Host, files []string) error { func restore(h host.Host) error { r, err := CommandRunner(&h) if err != nil { - return errors.Wrap(err, "command runner") + return fmt.Errorf("command runner: %w", err) } // check first if we have anything to restore out, err := r.RunCmd(exec.Command("sudo", "ls", "--almost-all", "-1", vmpath.GuestBackupDir)) if err != nil { - return errors.Wrapf(err, "read dir") + return fmt.Errorf("read dir: %w", err) } files := strings.Split(strings.TrimSpace(out.Stdout.String()), "\n") @@ -204,11 +206,11 @@ func restore(h host.Host) error { } src := path.Join(vmpath.GuestBackupDir, dst) if _, err := r.RunCmd(exec.Command("sudo", "rsync", "--archive", "--update", src, "/")); err != nil { - errs = append(errs, errors.Errorf("failed to copy %q to %q (will continue): %v", src, dst, err)) + errs = append(errs, fmt.Errorf("failed to copy %q to %q (will continue): %v", src, dst, err)) } } if len(errs) > 0 { - return errors.Errorf("%v", errs) + return fmt.Errorf("%v", errs) } return nil } diff --git a/pkg/minikube/machine/ssh.go b/pkg/minikube/machine/ssh.go index f32bf6ac4c..4cef19b47f 100644 --- a/pkg/minikube/machine/ssh.go +++ b/pkg/minikube/machine/ssh.go @@ -20,7 +20,6 @@ import ( "fmt" "os/exec" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/host" "k8s.io/minikube/pkg/libmachine/ssh" @@ -33,16 +32,16 @@ func GetHost(api libmachine.API, cc config.ClusterConfig, n config.Node) (*host. machineName := config.MachineName(cc, n) hostInfo, err := LoadHost(api, machineName) if err != nil { - return nil, errors.Wrap(err, "host exists and load") + return nil, fmt.Errorf("host exists and load: %w", err) } currentState, err := hostInfo.Driver.GetState() if err != nil { - return nil, errors.Wrap(err, "state") + return nil, fmt.Errorf("state: %w", err) } if currentState != state.Running { - return nil, errors.Errorf("%q is not running", machineName) + return nil, fmt.Errorf("%q is not running", machineName) } return hostInfo, nil @@ -64,7 +63,7 @@ func CreateSSHShell(api libmachine.API, cc config.ClusterConfig, n config.Node, client, err := hostInfo.CreateSSHClient() if err != nil { - return errors.Wrap(err, "Creating ssh client") + return fmt.Errorf("Creating ssh client: %w", err) } return client.Shell(args...) } diff --git a/pkg/minikube/machine/start.go b/pkg/minikube/machine/start.go index aba8959824..00369d2ec1 100644 --- a/pkg/minikube/machine/start.go +++ b/pkg/minikube/machine/start.go @@ -30,7 +30,6 @@ import ( "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic/oci" @@ -76,7 +75,7 @@ func StartHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) (* // Prevent machine-driver boot races, as well as our own certificate race releaser, err := acquireMachinesLock(machineName, cfg.Driver) if err != nil { - return nil, false, errors.Wrap(err, "boot lock") + return nil, false, fmt.Errorf("boot lock: %w", err) } start := time.Now() defer func() { @@ -86,7 +85,7 @@ func StartHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) (* exists, err := api.Exists(machineName) if err != nil { - return nil, false, errors.Wrapf(err, "exists: %s", machineName) + return nil, false, fmt.Errorf("exists: %s: %w", machineName, err) } var h *host.Host if !exists { @@ -138,16 +137,16 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( } dd, err := def.Config(*cfg, *n) if err != nil { - return nil, errors.Wrap(err, "config") + return nil, fmt.Errorf("config: %w", err) } data, err := json.Marshal(dd) if err != nil { - return nil, errors.Wrap(err, "marshal") + return nil, fmt.Errorf("marshal: %w", err) } h, err := api.NewHost(cfg.Driver, data) if err != nil { - return nil, errors.Wrap(err, "new host") + return nil, fmt.Errorf("new host: %w", err) } defer postStartValidations(h, cfg.Driver) @@ -162,7 +161,7 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( cfg.StartHostTimeout = 6 * time.Minute } if err := timedCreateHost(h, api, cfg.StartHostTimeout); err != nil { - return nil, errors.Wrap(err, "creating host") + return nil, fmt.Errorf("creating host: %w", err) } klog.Infof("duration metric: took %s to libmachine.API.Create %q", time.Since(cstart), cfg.Name) if cfg.Driver == driver.SSH { @@ -170,7 +169,7 @@ func createHost(api libmachine.API, cfg *config.ClusterConfig, n *config.Node) ( } if err := postStartSetup(h, *cfg); err != nil { - return h, errors.Wrap(err, "post-start") + return h, fmt.Errorf("post-start: %w", err) } if err := saveHost(api, h, cfg, n); err != nil { @@ -191,7 +190,7 @@ func timedCreateHost(h *host.Host, api libmachine.API, t time.Duration) error { if err != nil { // Wait for all the logs to reach the client time.Sleep(2 * time.Second) - return errors.Wrap(err, "create") + return fmt.Errorf("create: %w", err) } return nil case <-time.After(t): @@ -323,12 +322,12 @@ func postStartSetup(h *host.Host, mc config.ClusterConfig) error { r, err := CommandRunner(h) if err != nil { - return errors.Wrap(err, "command runner") + return fmt.Errorf("command runner: %w", err) } args := append([]string{"mkdir", "-p"}, requiredDirectories...) if _, err := r.RunCmd(exec.Command("sudo", args...)); err != nil { - return errors.Wrapf(err, "sudo mkdir (%s)", h.DriverName) + return fmt.Errorf("sudo mkdir (%s): %w", h.DriverName, err) } if driver.BareMetal(mc.Driver) { @@ -407,7 +406,7 @@ func AddHostAlias(c command.Runner, name string, ip net.IP) error { } if _, err := c.RunCmd(addHostAliasCommand(name, record, true, "/etc/hosts")); err != nil { - return errors.Wrap(err, "hosts update") + return fmt.Errorf("hosts update: %w", err) } return nil } diff --git a/pkg/minikube/machine/stop.go b/pkg/minikube/machine/stop.go index 787f441958..2a6e7bad0b 100644 --- a/pkg/minikube/machine/stop.go +++ b/pkg/minikube/machine/stop.go @@ -17,9 +17,9 @@ limitations under the License. package machine import ( + "fmt" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/libmachine" @@ -39,7 +39,7 @@ func StopHost(api libmachine.API, machineName string) error { klog.Infof("StopHost: %v", machineName) h, err := api.Load(machineName) if err != nil { - return errors.Wrapf(err, "load") + return fmt.Errorf("load: %w", err) } out.Step(style.Stopping, `Stopping node "{{.name}}" ...`, out.V{"name": machineName}) @@ -58,7 +58,7 @@ func stop(h *host.Host) error { if driver.NeedsShutdown(h.DriverName) { if err := trySSHPowerOff(h); err != nil { - return errors.Wrap(err, "ssh power off") + return fmt.Errorf("ssh power off: %w", err) } } @@ -69,7 +69,7 @@ func stop(h *host.Host) error { klog.Infof("host is already stopped") return nil } - return &retry.RetriableError{Err: errors.Wrap(err, "stop")} + return &retry.RetriableError{Err: fmt.Errorf("stop: %w", err)} } klog.Infof("duration metric: took %s to stop", time.Since(start)) diff --git a/pkg/minikube/node/advice.go b/pkg/minikube/node/advice.go index 76b8533872..a513dc307e 100644 --- a/pkg/minikube/node/advice.go +++ b/pkg/minikube/node/advice.go @@ -20,7 +20,8 @@ import ( "fmt" "runtime" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/drivers/kic/oci" "k8s.io/minikube/pkg/minikube/bootstrapper/kubeadm" "k8s.io/minikube/pkg/minikube/cruntime" diff --git a/pkg/minikube/node/cache.go b/pkg/minikube/node/cache.go index d7fe818af3..9b9635aaa8 100644 --- a/pkg/minikube/node/cache.go +++ b/pkg/minikube/node/cache.go @@ -28,7 +28,8 @@ import ( "k8s.io/minikube/pkg/minikube/detect" "k8s.io/minikube/pkg/minikube/run" - "github.com/pkg/errors" + "errors" + "github.com/spf13/viper" "golang.org/x/sync/errgroup" "k8s.io/klog/v2" @@ -271,7 +272,7 @@ func saveImagesToTarFromConfig() error { func CacheAndLoadImagesInConfig(profiles []*config.Profile, options *run.CommandOptions) error { images, err := imagesInConfigFile() if err != nil { - return errors.Wrap(err, "images") + return fmt.Errorf("images: %w", err) } if len(images) == 0 { return nil @@ -282,7 +283,7 @@ func CacheAndLoadImagesInConfig(profiles []*config.Profile, options *run.Command func imagesInConfigFile() ([]string, error) { configFile, err := config.ReadConfig(localpath.ConfigFile()) if err != nil { - return nil, errors.Wrap(err, "read") + return nil, fmt.Errorf("read: %w", err) } if values, ok := configFile[cacheImageConfigKey]; ok { // Type assertion needed because config values are stored as interface{} diff --git a/pkg/minikube/node/node.go b/pkg/minikube/node/node.go index 663372597e..75a9aef08c 100644 --- a/pkg/minikube/node/node.go +++ b/pkg/minikube/node/node.go @@ -24,8 +24,9 @@ import ( "strings" "time" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -57,7 +58,7 @@ func Add(cc *config.ClusterConfig, n config.Node, delOnFail bool, options *run.C for _, existNode := range p.Config.Nodes { if machineName == config.MachineName(*p.Config, existNode) { - return errors.Errorf("Node %s already exists in %s profile", machineName, p.Name) + return fmt.Errorf("Node %s already exists in %s profile", machineName, p.Name) } } } @@ -67,7 +68,7 @@ func Add(cc *config.ClusterConfig, n config.Node, delOnFail bool, options *run.C } if err := config.SaveNode(cc, &n); err != nil { - return errors.Wrap(err, "save node") + return fmt.Errorf("save node: %w", err) } r, p, m, h, err := Provision(cc, &n, delOnFail, options) @@ -94,23 +95,23 @@ func teardown(cc config.ClusterConfig, name string, options *run.CommandOptions) // get runner for named node - has to be done before node is drained n, _, err := Retrieve(cc, name) if err != nil { - return n, errors.Wrap(err, "retrieve node") + return n, fmt.Errorf("retrieve node: %w", err) } m := config.MachineName(cc, *n) api, err := machine.NewAPIClient(options) if err != nil { - return n, errors.Wrap(err, "get api client") + return n, fmt.Errorf("get api client: %w", err) } h, err := machine.LoadHost(api, m) if err != nil { - return n, errors.Wrap(err, "load host") + return n, fmt.Errorf("load host: %w", err) } r, err := machine.CommandRunner(h) if err != nil { - return n, errors.Wrap(err, "get command runner") + return n, fmt.Errorf("get command runner: %w", err) } // get runner for healthy control-plane node @@ -203,7 +204,7 @@ func Delete(cc config.ClusterConfig, name string, options *run.CommandOptions) ( _, index, err := Retrieve(cc, name) if err != nil { - return n, errors.Wrap(err, "retrieve") + return n, fmt.Errorf("retrieve: %w", err) } cc.Nodes = append(cc.Nodes[:index], cc.Nodes[index+1:]...) diff --git a/pkg/minikube/node/start.go b/pkg/minikube/node/start.go index 009f5a317b..13d31ed183 100755 --- a/pkg/minikube/node/start.go +++ b/pkg/minikube/node/start.go @@ -29,8 +29,9 @@ import ( "sync" "time" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "golang.org/x/sync/errgroup" meta "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -114,7 +115,7 @@ func Start(starter Starter, options *run.CommandOptions) (*kubeconfig.Settings, sv, err := util.ParseKubernetesVersion(starter.Node.KubernetesVersion) if err != nil { - return nil, errors.Wrap(err, "Failed to parse Kubernetes version") + return nil, fmt.Errorf("Failed to parse Kubernetes version: %w", err) } // configure the runtime (docker, containerd, crio) @@ -166,17 +167,17 @@ func Start(starter Starter, options *run.CommandOptions) (*kubeconfig.Settings, } else { bs, err = cluster.Bootstrapper(starter.MachineAPI, viper.GetString(cmdcfg.Bootstrapper), *starter.Cfg, starter.Runner) if err != nil { - return nil, errors.Wrap(err, "Failed to get bootstrapper") + return nil, fmt.Errorf("Failed to get bootstrapper: %w", err) } // for ha (multi-control plane) cluster, use already running control-plane node to copy over certs to this secondary control-plane node cpr := mustload.Running(starter.Cfg.Name, options).CP.Runner if err = bs.SetupCerts(*starter.Cfg, *starter.Node, cpr); err != nil { - return nil, errors.Wrap(err, "setting up certs") + return nil, fmt.Errorf("setting up certs: %w", err) } if err := bs.UpdateNode(*starter.Cfg, *starter.Node, cr); err != nil { - return nil, errors.Wrap(err, "update node") + return nil, fmt.Errorf("update node: %w", err) } // join cluster only on first node start @@ -185,10 +186,10 @@ func Start(starter Starter, options *run.CommandOptions) (*kubeconfig.Settings, // make sure to use the command runner for the primary control plane to generate the join token pcpBs, err := cluster.ControlPlaneBootstrapper(starter.MachineAPI, starter.Cfg, viper.GetString(cmdcfg.Bootstrapper)) if err != nil { - return nil, errors.Wrap(err, "get primary control-plane bootstrapper") + return nil, fmt.Errorf("get primary control-plane bootstrapper: %w", err) } if err := joinCluster(starter, pcpBs, bs, options); err != nil { - return nil, errors.Wrap(err, "join node to cluster") + return nil, fmt.Errorf("join node to cluster: %w", err) } } } @@ -235,7 +236,7 @@ func Start(starter Starter, options *run.CommandOptions) (*kubeconfig.Settings, } else { klog.Infof("Will wait %s for node %+v", viper.GetDuration(waitTimeout), starter.Node) if err := bs.WaitForNode(*starter.Cfg, *starter.Node, viper.GetDuration(waitTimeout)); err != nil { - return nil, errors.Wrapf(err, "wait %s for node", viper.GetDuration(waitTimeout)) + return nil, fmt.Errorf("wait %s for node: %w", viper.GetDuration(waitTimeout), err) } } @@ -283,7 +284,7 @@ func startPrimaryControlPlane(starter Starter, cr cruntime.Manager, options *run if config.IsHA(*starter.Cfg) { n, err := network.Inspect(starter.Node.IP) if err != nil { - return nil, nil, errors.Wrapf(err, "inspect network") + return nil, nil, fmt.Errorf("inspect network: %w", err) } // update cluster config starter.Cfg.KubernetesConfig.APIServerHAVIP = n.ClientMax // last available ip from node's subnet, should've been reserved already @@ -295,7 +296,7 @@ func startPrimaryControlPlane(starter Starter, cr cruntime.Manager, options *run // setup kubeadm (must come after setupKubeconfig) bs, err := setupKubeadm(starter.MachineAPI, *starter.Cfg, *starter.Node, starter.Runner) if err != nil { - return nil, nil, errors.Wrap(err, "Failed to setup kubeadm") + return nil, nil, fmt.Errorf("Failed to setup kubeadm: %w", err) } if err := bs.StartCluster(*starter.Cfg, options); err != nil { @@ -306,7 +307,7 @@ func startPrimaryControlPlane(starter Starter, cr cruntime.Manager, options *run // Write the kubeconfig to the file system after everything required (like certs) are created by the bootstrapper. if err := kubeconfig.Update(kcs); err != nil { - return nil, bs, errors.Wrap(err, "Failed kubeconfig update") + return nil, bs, fmt.Errorf("Failed kubeconfig update: %w", err) } return kcs, bs, nil @@ -397,7 +398,7 @@ func Provision(cc *config.ClusterConfig, n *config.Node, delOnFail bool, options // Abstraction leakage alert: startHost requires the config to be saved, to satisfy pkg/provision/buildroot. // Hence, SaveProfile must be called before startHost, and again afterwards when we know the IP. if err := config.SaveProfile(viper.GetString(config.ProfileName), cc); err != nil { - return nil, false, nil, nil, errors.Wrap(err, "Failed to save config") + return nil, false, nil, nil, fmt.Errorf("Failed to save config: %w", err) } handleDownloadOnly(&cacheGroup, &kicGroup, n.KubernetesVersion, cc.KubernetesConfig.ContainerRuntime, cc.Driver, options) @@ -668,26 +669,26 @@ func setupKubeconfig(h host.Host, cc config.ClusterConfig, n config.Node, cluste func startMachine(cfg *config.ClusterConfig, node *config.Node, delOnFail bool, options *run.CommandOptions) (runner command.Runner, preExists bool, machineAPI libmachine.API, hostInfo *host.Host, err error) { m, err := machine.NewAPIClient(options) if err != nil { - return runner, preExists, m, hostInfo, errors.Wrap(err, "Failed to get machine client") + return runner, preExists, m, hostInfo, fmt.Errorf("Failed to get machine client: %w", err) } hostInfo, preExists, err = startHostInternal(m, cfg, node, delOnFail) if err != nil { - return runner, preExists, m, hostInfo, errors.Wrap(err, "Failed to start host") + return runner, preExists, m, hostInfo, fmt.Errorf("Failed to start host: %w", err) } runner, err = machine.CommandRunner(hostInfo) if err != nil { - return runner, preExists, m, hostInfo, errors.Wrap(err, "Failed to get command runner") + return runner, preExists, m, hostInfo, fmt.Errorf("Failed to get command runner: %w", err) } ip, err := validateNetwork(hostInfo, runner, cfg.KubernetesConfig.ImageRepository) if err != nil { - return runner, preExists, m, hostInfo, errors.Wrap(err, "Failed to validate network") + return runner, preExists, m, hostInfo, fmt.Errorf("Failed to validate network: %w", err) } if driver.IsQEMU(hostInfo.Driver.DriverName()) && network.IsBuiltinQEMU(cfg.Network) { apiServerPort, err := getPort() if err != nil { - return runner, preExists, m, hostInfo, errors.Wrap(err, "Failed to find apiserver port") + return runner, preExists, m, hostInfo, fmt.Errorf("Failed to find apiserver port: %w", err) } cfg.APIServerPort = apiServerPort } @@ -710,7 +711,7 @@ func getPort() (int, error) { l, err := net.ListenTCP("tcp", addr) if err != nil { - return -1, errors.Errorf("Error accessing port %d", addr.Port) + return -1, fmt.Errorf("Error accessing port %d", addr.Port) } defer l.Close() return l.Addr().(*net.TCPAddr).Port, nil @@ -731,7 +732,8 @@ func startHostInternal(api libmachine.API, cc *config.ClusterConfig, n *config.N } } - if err, ff := errors.Cause(err).(*oci.FailFastError); ff { + var ff *oci.FailFastError + if errors.As(err, &ff) { klog.Infof("will skip retrying to create machine because error is not retriable: %v", err) return hostInfo, exists, err } diff --git a/pkg/minikube/notify/notify.go b/pkg/minikube/notify/notify.go index efd19d7d64..300ae4a413 100644 --- a/pkg/minikube/notify/notify.go +++ b/pkg/minikube/notify/notify.go @@ -26,7 +26,6 @@ import ( "time" "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/config" @@ -171,7 +170,7 @@ func getJSON(url string, target *Releases) error { req, err := http.NewRequest("GET", url, nil) if err != nil { - return errors.Wrap(err, "error creating new http request") + return fmt.Errorf("error creating new http request: %w", err) } ua := fmt.Sprintf("Minikube/%s Minikube-OS/%s Minikube-Arch/%s Minikube-Plaform/%s Minikube-Cloud/%s", version.GetVersion(), runtime.GOOS, runtime.GOARCH, platform(), cloud()) @@ -180,7 +179,7 @@ func getJSON(url string, target *Releases) error { resp, err := client.Do(req) if err != nil { - return errors.Wrapf(err, "error with http GET for endpoint %s", url) + return fmt.Errorf("error with http GET for endpoint %s: %w", url, err) } defer resp.Body.Close() @@ -220,10 +219,10 @@ func AllVersionsFromURL(url string) (Releases, error) { var releases Releases klog.Info("Checking for updates...") if err := getJSON(url, &releases); err != nil { - return releases, errors.Wrap(err, "Error getting json from minikube version url") + return releases, fmt.Errorf("Error getting json from minikube version url: %w", err) } if len(releases.Releases) == 0 { - return releases, errors.Errorf("There were no json releases at the url specified: %s", url) + return releases, fmt.Errorf("There were no json releases at the url specified: %s", url) } return releases, nil } @@ -231,7 +230,7 @@ func AllVersionsFromURL(url string) (Releases, error) { func writeTimeToFile(path string, inputTime time.Time) error { err := lock.WriteFile(path, []byte(inputTime.Format(timeLayout)), 0o644) if err != nil { - return errors.Wrap(err, "Error writing current update time to file: ") + return fmt.Errorf("Error writing current update time to file: : %w", err) } return nil } diff --git a/pkg/minikube/perf/binary.go b/pkg/minikube/perf/binary.go index 22fa26583b..4dc0d6d681 100644 --- a/pkg/minikube/perf/binary.go +++ b/pkg/minikube/perf/binary.go @@ -28,7 +28,6 @@ import ( "time" "cloud.google.com/go/storage" - "github.com/pkg/errors" "google.golang.org/api/option" "k8s.io/minikube/pkg/minikube/constants" "k8s.io/minikube/pkg/util/retry" @@ -68,7 +67,7 @@ func (b *Binary) download() error { ctx := context.Background() client, err := storage.NewClient(ctx, option.WithoutAuthentication()) if err != nil { - return errors.Wrap(err, "getting storage client") + return fmt.Errorf("getting storage client: %w", err) } defer client.Close() @@ -80,7 +79,7 @@ func (b *Binary) download() error { rc, err := obj.NewReader(ctx) if err != nil { - return errors.Wrap(err, "getting minikube object from gcs bucket") + return fmt.Errorf("getting minikube object from gcs bucket: %w", err) } defer rc.Close() @@ -104,7 +103,7 @@ func newBinaryFromPR(pr string) (*Binary, error) { // try to convert to int i, err := strconv.Atoi(pr) if err != nil { - return nil, errors.Wrapf(err, "converting %s to an integer", pr) + return nil, fmt.Errorf("converting %s to an integer: %w", pr, err) } b := &Binary{ @@ -113,7 +112,7 @@ func newBinaryFromPR(pr string) (*Binary, error) { } if err := retry.Expo(b.download, 1*time.Minute, 10*time.Minute); err != nil { - return nil, errors.Wrapf(err, "downloading binary") + return nil, fmt.Errorf("downloading binary: %w", err) } return b, nil diff --git a/pkg/minikube/perf/logs.go b/pkg/minikube/perf/logs.go index 1ac440abc2..280d84e6e3 100644 --- a/pkg/minikube/perf/logs.go +++ b/pkg/minikube/perf/logs.go @@ -18,13 +18,12 @@ package perf import ( "bufio" + "fmt" "log" "os/exec" "strings" "time" - "github.com/pkg/errors" - "k8s.io/klog/v2" ) @@ -36,14 +35,14 @@ func timeCommandLogs(cmd *exec.Cmd) (*result, error) { stdout, err := cmd.StdoutPipe() if err != nil { - return nil, errors.Wrap(err, "getting stdout pipe") + return nil, fmt.Errorf("getting stdout pipe: %w", err) } scanner := bufio.NewScanner(stdout) scanner.Split(bufio.ScanLines) log.Printf("Running: %v...", cmd.Args) if err := cmd.Start(); err != nil { - return nil, errors.Wrap(err, "starting cmd") + return nil, fmt.Errorf("starting cmd: %w", err) } timer := time.Now() @@ -67,7 +66,7 @@ func timeCommandLogs(cmd *exec.Cmd) (*result, error) { } if err := cmd.Wait(); err != nil { - return nil, errors.Wrap(err, "waiting for minikube") + return nil, fmt.Errorf("waiting for minikube: %w", err) } return r, nil } diff --git a/pkg/minikube/perf/start.go b/pkg/minikube/perf/start.go index 4ba3f9ba6c..3471e4b163 100644 --- a/pkg/minikube/perf/start.go +++ b/pkg/minikube/perf/start.go @@ -23,8 +23,6 @@ import ( "os" "os/exec" "runtime" - - "github.com/pkg/errors" ) const ( @@ -70,13 +68,13 @@ func collectResults(ctx context.Context, binaries []*Binary, driver string, runt for _, binary := range binaries { r, err := timeMinikubeStart(ctx, binary, driver, runtimeName) if err != nil { - return nil, errors.Wrapf(err, "timing run %d with %s", run, binary.Name()) + return nil, fmt.Errorf("timing run %d with %s: %w", run, binary.Name(), err) } rm.addResult(binary, "start", *r) if !skipIngress(driver) { r, err = timeEnableIngress(ctx, binary) if err != nil { - return nil, errors.Wrapf(err, "timing run %d with %s", run, binary.Name()) + return nil, fmt.Errorf("timing run %d with %s: %w", run, binary.Name(), err) } rm.addResult(binary, "ingress", *r) } @@ -103,12 +101,12 @@ func downloadArtifacts(ctx context.Context, binaries []*Binary, driver string, r c.Stderr = os.Stderr log.Printf("Running: %v...", c.Args) if err := c.Run(); err != nil { - return errors.Wrap(err, "artifact download start") + return fmt.Errorf("artifact download start: %w", err) } c = exec.CommandContext(ctx, b.path, "delete") log.Printf("Running: %v...", c.Args) if err := c.Run(); err != nil { - return errors.Wrap(err, "artifact download delete") + return fmt.Errorf("artifact download delete: %w", err) } } return nil @@ -121,7 +119,7 @@ func timeMinikubeStart(ctx context.Context, binary *Binary, driver string, runti r, err := timeCommandLogs(startCmd) if err != nil { - return nil, errors.Wrapf(err, "timing cmd: %v", startCmd.Args) + return nil, fmt.Errorf("timing cmd: %v: %w", startCmd.Args, err) } return r, nil } @@ -134,7 +132,7 @@ func timeEnableIngress(ctx context.Context, binary *Binary) (*result, error) { r, err := timeCommandLogs(enableCmd) if err != nil { - return nil, errors.Wrapf(err, "timing cmd: %v", enableCmd.Args) + return nil, fmt.Errorf("timing cmd: %v: %w", enableCmd.Args, err) } return r, nil } diff --git a/pkg/minikube/proxy/proxy.go b/pkg/minikube/proxy/proxy.go index d1fb8478a4..0f44c7a74f 100644 --- a/pkg/minikube/proxy/proxy.go +++ b/pkg/minikube/proxy/proxy.go @@ -25,7 +25,8 @@ import ( "regexp" "strings" - "github.com/pkg/errors" + "errors" + "k8s.io/client-go/rest" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/config" @@ -58,7 +59,7 @@ func isInBlock(ip string, block string) (bool, error) { if strings.Contains(block, "/") { _, b, err := net.ParseCIDR(block) if err != nil { - return false, errors.Wrapf(err, "Error Parsing block %s", b) + return false, fmt.Errorf("Error Parsing block %s: %w", b, err) } if b.Contains(i) { diff --git a/pkg/minikube/registry/drvs/docker/docker.go b/pkg/minikube/registry/drvs/docker/docker.go index c75d8a92d6..1315b622f5 100644 --- a/pkg/minikube/registry/drvs/docker/docker.go +++ b/pkg/minikube/registry/drvs/docker/docker.go @@ -25,8 +25,9 @@ import ( "strings" "time" + "errors" + "github.com/blang/semver/v4" - "github.com/pkg/errors" "github.com/spf13/viper" "k8s.io/klog/v2" "k8s.io/minikube/pkg/drivers/kic" @@ -136,7 +137,7 @@ func status(_ *run.CommandOptions) (retState registry.State) { si, err := oci.CachedDaemonInfo("docker") if err != nil { // No known fix because we haven't yet seen a failure here - return registry.State{Reason: "PROVIDER_DOCKER_INFO_FAILED", Error: errors.Wrap(err, "docker info"), Installed: true, Healthy: false, Doc: docURL} + return registry.State{Reason: "PROVIDER_DOCKER_INFO_FAILED", Error: fmt.Errorf("docker info: %w", err), Installed: true, Healthy: false, Doc: docURL} } for _, serr := range si.Errors { @@ -175,7 +176,7 @@ var dockerVersionOrState = func() (string, registry.State) { reason := "" if ctx.Err() == context.DeadlineExceeded { - err = errors.Wrapf(err, "deadline exceeded running %q", strings.Join(cmd.Args, " ")) + err = fmt.Errorf("deadline exceeded running %q: %w", strings.Join(cmd.Args, " "), err) reason = "PROVIDER_DOCKER_DEADLINE_EXCEEDED" } @@ -196,7 +197,7 @@ func checkDockerEngineVersion(o string) registry.State { if len(parts) != 2 { return registry.State{ Reason: "PROVIDER_DOCKER_VERSION_PARSING_FAILED", - Error: errors.Errorf("expected version string format is \"{{.Server.Os}}-{{.Server.Version}}\". but got %s", o), + Error: fmt.Errorf("expected version string format is \"{{.Server.Os}}-{{.Server.Version}}\". but got %s", o), Installed: true, Healthy: false, Doc: docURL, diff --git a/pkg/minikube/registry/drvs/hyperkit/hyperkit.go b/pkg/minikube/registry/drvs/hyperkit/hyperkit.go index 29fcc53648..3e2948774e 100644 --- a/pkg/minikube/registry/drvs/hyperkit/hyperkit.go +++ b/pkg/minikube/registry/drvs/hyperkit/hyperkit.go @@ -25,8 +25,6 @@ import ( "strings" "time" - "github.com/pkg/errors" - "github.com/google/uuid" "k8s.io/minikube/pkg/libmachine/drivers" @@ -123,11 +121,11 @@ func isNewerVersion(currentVersion string, specificVersion string) (bool, error) layout := "20060102" currentVersionDate, err := time.Parse(layout, currentVersion) if err != nil { - return false, errors.Wrap(err, "parse date") + return false, fmt.Errorf("parse date: %w", err) } specificVersionDate, err := time.Parse(layout, specificVersion) if err != nil { - return false, errors.Wrap(err, "parse date") + return false, fmt.Errorf("parse date: %w", err) } // If currentVersionDate is equal to specificVersionDate, no need to upgrade hyperkit if currentVersionDate.Equal(specificVersionDate) { diff --git a/pkg/minikube/registry/drvs/hyperv/hyperv.go b/pkg/minikube/registry/drvs/hyperv/hyperv.go index 30655537e0..d45cffae9e 100644 --- a/pkg/minikube/registry/drvs/hyperv/hyperv.go +++ b/pkg/minikube/registry/drvs/hyperv/hyperv.go @@ -25,7 +25,6 @@ import ( "strings" "time" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/drivers/hyperv" @@ -62,7 +61,7 @@ func configure(cfg config.ClusterConfig, n config.Node) (interface{}, error) { if d.VSwitch == "" && cfg.HypervUseExternalSwitch { switchName, adapter, err := chooseSwitch(cfg.HypervExternalAdapter) if err != nil { - return nil, errors.Wrapf(err, "failed to choose switch for Hyper-V driver") + return nil, fmt.Errorf("failed to choose switch for Hyper-V driver: %w", err) } if cfg.HypervExternalAdapter == "" && switchName == "" { // create a switch on the returned adapter diff --git a/pkg/minikube/registry/drvs/hyperv/vswitch.go b/pkg/minikube/registry/drvs/hyperv/vswitch.go index 0bbea59c8f..37c2df79ba 100644 --- a/pkg/minikube/registry/drvs/hyperv/vswitch.go +++ b/pkg/minikube/registry/drvs/hyperv/vswitch.go @@ -22,8 +22,6 @@ import ( "encoding/json" "fmt" "strings" - - "github.com/pkg/errors" ) type netAdapter struct { @@ -136,7 +134,7 @@ func getOrderedAdapters() ([]netAdapter, error) { func createVMSwitch(switchName string, adapter netAdapter) error { err := cmd(fmt.Sprintf("Hyper-V\\New-VMSwitch -Name \"%s\" -NetAdapterInterfaceDescription \"%s\"", switchName, adapter.InterfaceDescription)) if err != nil { - return errors.Wrapf(err, "failed to create VM switch %s with adapter %s", switchName, adapter.InterfaceGUID) + return fmt.Errorf("failed to create VM switch %s with adapter %s: %w", switchName, adapter.InterfaceGUID, err) } return nil @@ -153,7 +151,7 @@ func chooseSwitch(adapterName string) (string, netAdapter, error) { } if len(foundAdapters) == 0 { - return "", netAdapter{}, errors.Errorf("adapter %s not found", adapterName) + return "", netAdapter{}, fmt.Errorf("adapter %s not found", adapterName) } adapter = foundAdapters[0] @@ -167,12 +165,12 @@ func chooseSwitch(adapterName string) (string, netAdapter, error) { } if len(adapters) == 0 { - return "", netAdapter{}, errors.Errorf("no connected adapter available") + return "", netAdapter{}, fmt.Errorf("no connected adapter available") } externalVMSwitches, err := getVMSwitch("($_.SwitchType -eq 2)") if err != nil { - return "", netAdapter{}, errors.Wrapf(err, "failed to list external VM switches") + return "", netAdapter{}, fmt.Errorf("failed to list external VM switches: %w", err) } if len(externalVMSwitches) > 0 { diff --git a/pkg/minikube/registry/drvs/ssh/ssh.go b/pkg/minikube/registry/drvs/ssh/ssh.go index 9ed5bebb95..d17270965c 100644 --- a/pkg/minikube/registry/drvs/ssh/ssh.go +++ b/pkg/minikube/registry/drvs/ssh/ssh.go @@ -22,7 +22,6 @@ import ( "path/filepath" "strings" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/drivers/ssh" @@ -56,13 +55,13 @@ func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { }) if cc.SSHIPAddress == "" { - return nil, errors.Errorf("please provide an IP address") + return nil, fmt.Errorf("please provide an IP address") } // We don't want the API server listening on loopback interface, // even if we might use a tunneled VM port for the SSH service if cc.SSHIPAddress == "127.0.0.1" || cc.SSHIPAddress == "localhost" { - return nil, errors.Errorf("please provide real IP address") + return nil, fmt.Errorf("please provide real IP address") } d.IPAddress = cc.SSHIPAddress @@ -71,7 +70,7 @@ func configure(cc config.ClusterConfig, n config.Node) (interface{}, error) { if strings.HasPrefix(cc.SSHKey, "~") { dirname, err := os.UserHomeDir() if err != nil { - return nil, errors.Errorf("Error determining path to ssh key: %v", err) + return nil, fmt.Errorf("Error determining path to ssh key: %v", err) } d.SSHKey = filepath.Join(dirname, cc.SSHKey[1:]) } else { diff --git a/pkg/minikube/schedule/daemonize_unix.go b/pkg/minikube/schedule/daemonize_unix.go index 59b0c88de3..5d74fbb39e 100644 --- a/pkg/minikube/schedule/daemonize_unix.go +++ b/pkg/minikube/schedule/daemonize_unix.go @@ -25,7 +25,6 @@ import ( "time" "github.com/VividCortex/godaemon" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/localpath" @@ -60,19 +59,19 @@ func killPIDForProfile(profile string) error { } }() if err != nil { - return errors.Wrapf(err, "reading %s", file) + return fmt.Errorf("reading %s: %w", file, err) } pid, err := strconv.Atoi(string(f)) if err != nil { - return errors.Wrapf(err, "converting %s to int", f) + return fmt.Errorf("converting %s to int: %w", f, err) } p, err := os.FindProcess(pid) if err != nil { - return errors.Wrap(err, "finding process") + return fmt.Errorf("finding process: %w", err) } klog.Infof("killing process %v as it is an old scheduled stop", pid) if err := p.Kill(); err != nil { - return errors.Wrapf(err, "killing %v", pid) + return fmt.Errorf("killing %v: %w", pid, err) } return nil } diff --git a/pkg/minikube/schedule/daemonize_windows.go b/pkg/minikube/schedule/daemonize_windows.go index bd29dc96cf..d45f77c18c 100644 --- a/pkg/minikube/schedule/daemonize_windows.go +++ b/pkg/minikube/schedule/daemonize_windows.go @@ -23,7 +23,6 @@ import ( "os/exec" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/constants" @@ -45,20 +44,20 @@ func killExisting(profile string, options *run.CommandOptions) error { klog.Infof("trying to kill existing schedule stop for profile %s...", profile) api, err := machine.NewAPIClient(options) if err != nil { - return errors.Wrapf(err, "getting api client for profile %s", profile) + return fmt.Errorf("getting api client for profile %s: %w", profile, err) } h, err := api.Load(profile) if err != nil { - return errors.Wrap(err, "Error loading existing host. Please try running [minikube delete], then run [minikube start] again.") + return fmt.Errorf("Error loading existing host. Please try running [minikube delete], then run [minikube start] again.: %w", err) } runner, err := machine.CommandRunner(h) if err != nil { - return errors.Wrap(err, "getting command runner") + return fmt.Errorf("getting command runner: %w", err) } // restart scheduled stop service in container sysManger := sysinit.New(runner) if err := sysManger.Stop(constants.ScheduledStopSystemdService); err != nil { - return errors.Wrapf(err, "stopping schedule-stop service for profile %s", profile) + return fmt.Errorf("stopping schedule-stop service for profile %s: %w", profile, err) } return nil } @@ -68,7 +67,7 @@ func killExisting(profile string, options *run.CommandOptions) error { func daemonize(profiles []string, duration time.Duration, options *run.CommandOptions) error { for _, profile := range profiles { if err := startSystemdService(profile, duration, options); err != nil { - return errors.Wrapf(err, "implementing scheduled stop for %s", profile) + return fmt.Errorf("implementing scheduled stop for %s: %w", profile, err) } } return nil @@ -83,22 +82,22 @@ func startSystemdService(profile string, duration time.Duration, options *run.Co klog.Infof("starting systemd service for profile %s...", profile) api, err := machine.NewAPIClient(options) if err != nil { - return errors.Wrapf(err, "getting api client for profile %s", profile) + return fmt.Errorf("getting api client for profile %s: %w", profile, err) } h, err := api.Load(profile) if err != nil { - return errors.Wrap(err, "Error loading existing host. Please try running [minikube delete], then run [minikube start] again.") + return fmt.Errorf("Error loading existing host. Please try running [minikube delete], then run [minikube start] again.: %w", err) } runner, err := machine.CommandRunner(h) if err != nil { - return errors.Wrap(err, "getting command runner") + return fmt.Errorf("getting command runner: %w", err) } if rr, err := runner.RunCmd(exec.Command("sudo", "mkdir", "-p", "/var/lib/minikube/scheduled-stop")); err != nil { - return errors.Wrapf(err, "creating dirs: %v", rr.Output()) + return fmt.Errorf("creating dirs: %v: %w", rr.Output(), err) } // update environment file to include duration if err := runner.Copy(environmentFile(duration)); err != nil { - return errors.Wrap(err, "copying scheduled stop env file") + return fmt.Errorf("copying scheduled stop env file: %w", err) } // restart scheduled stop service in container sysManager := sysinit.New(runner) diff --git a/pkg/minikube/schedule/schedule.go b/pkg/minikube/schedule/schedule.go index d07a77a486..27508998c4 100644 --- a/pkg/minikube/schedule/schedule.go +++ b/pkg/minikube/schedule/schedule.go @@ -17,9 +17,9 @@ limitations under the License. package schedule import ( + "fmt" "time" - "github.com/pkg/errors" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/driver" "k8s.io/minikube/pkg/minikube/mustload" @@ -45,7 +45,7 @@ func Daemonize(profiles []string, duration time.Duration, options *run.CommandOp } if err := daemonize(daemonizeProfiles, duration, options); err != nil { - return errors.Wrap(err, "daemonizing") + return fmt.Errorf("daemonizing: %w", err) } // save scheduled stop config if daemonize was successful @@ -53,7 +53,7 @@ func Daemonize(profiles []string, duration time.Duration, options *run.CommandOp _, cc := mustload.Partial(d, options) cc.ScheduledStop = scheduledStop if err := config.SaveProfile(d, cc); err != nil { - return errors.Wrap(err, "saving profile") + return fmt.Errorf("saving profile: %w", err) } } return nil diff --git a/pkg/minikube/service/service.go b/pkg/minikube/service/service.go index 7159d764a3..958bc26ac7 100644 --- a/pkg/minikube/service/service.go +++ b/pkg/minikube/service/service.go @@ -28,9 +28,10 @@ import ( "text/template" "time" + "errors" + "github.com/olekukonko/tablewriter" "github.com/olekukonko/tablewriter/tw" - "github.com/pkg/errors" core "k8s.io/api/core/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/labels" @@ -70,7 +71,7 @@ func init() { func (k *K8sClientGetter) GetCoreClient(ctx string) (typed_core.CoreV1Interface, error) { client, err := kapi.Client(ctx) if err != nil { - return nil, errors.Wrap(err, "client") + return nil, fmt.Errorf("client: %w", err) } return client.CoreV1(), nil } @@ -129,12 +130,12 @@ func GetServiceURLs(api libmachine.API, cname string, namespace string, t *templ func GetServiceURLsForService(api libmachine.API, cname string, namespace, service string, t *template.Template) (SvcURL, error) { host, err := machine.LoadHost(api, cname) if err != nil { - return SvcURL{}, errors.Wrap(err, "Error checking if api exist and loading it") + return SvcURL{}, fmt.Errorf("Error checking if api exist and loading it: %w", err) } ip, err := host.Driver.GetIP() if err != nil { - return SvcURL{}, errors.Wrap(err, "Error getting ip from host") + return SvcURL{}, fmt.Errorf("Error getting ip from host: %w", err) } client, err := K8s.GetCoreClient(cname) @@ -152,7 +153,7 @@ func printURLsForService(c typed_core.CoreV1Interface, ip, service, namespace st svc, err := c.Services(namespace).Get(context.Background(), service, meta.GetOptions{}) if err != nil { - return SvcURL{}, errors.Wrapf(err, "service '%s' could not be found running", service) + return SvcURL{}, fmt.Errorf("service '%s' could not be found running: %w", service, err) } endpoints, err := c.Endpoints(namespace).Get(context.Background(), service, meta.GetOptions{}) @@ -200,13 +201,13 @@ func printURLsForService(c typed_core.CoreV1Interface, ip, service, namespace st func CheckService(cname string, namespace string, service string) error { client, err := K8s.GetCoreClient(cname) if err != nil { - return errors.Wrap(err, "Error getting Kubernetes client") + return fmt.Errorf("Error getting Kubernetes client: %w", err) } svc, err := client.Services(namespace).Get(context.Background(), service, meta.GetOptions{}) if err != nil { return &retry.RetriableError{ - Err: errors.Wrapf(err, "Error getting service %s", service), + Err: fmt.Errorf("Error getting service %s: %w", service, err), } } if len(svc.Spec.Ports) == 0 { @@ -275,7 +276,7 @@ func WaitForService(api libmachine.API, cname string, namespace string, service serviceURL, err := GetServiceURLsForService(api, cname, namespace, service, urlTemplate) if err != nil { - return urlList, errors.Wrap(err, "Check that minikube is running and that you have specified the correct namespace") + return urlList, fmt.Errorf("Check that minikube is running and that you have specified the correct namespace: %w", err) } if !urlMode { @@ -384,12 +385,12 @@ func DeleteSecret(cname string, namespace, name string) error { func CheckServicePods(cname, svcName, namespace string) error { clientset, err := K8s.GetCoreClient(cname) if err != nil { - return errors.Wrap(err, "failed to get k8s client") + return fmt.Errorf("failed to get k8s client: %w", err) } svc, err := clientset.Services(namespace).Get(context.Background(), svcName, meta.GetOptions{}) if err != nil { - return errors.Wrap(err, "Get service") + return fmt.Errorf("Get service: %w", err) } // There are four types of service in k8s: NodePort, ClusterIp, LoadBalancer and ExternalName // However, NodePort means that this service will not be exposed outside the cluster @@ -402,7 +403,7 @@ func CheckServicePods(cname, svcName, namespace string) error { LabelSelector: labels.Set(svc.Spec.Selector).AsSelector().String(), }) if err != nil { - return errors.Wrap(err, "List Pods") + return fmt.Errorf("List Pods: %w", err) } for _, pod := range pods.Items { diff --git a/pkg/minikube/service/service_test.go b/pkg/minikube/service/service_test.go index 031bd87e44..8a51e9bc5e 100644 --- a/pkg/minikube/service/service_test.go +++ b/pkg/minikube/service/service_test.go @@ -28,7 +28,8 @@ import ( "text/template" "time" - "github.com/pkg/errors" + "errors" + "github.com/spf13/viper" core "k8s.io/api/core/v1" discoveryv1 "k8s.io/api/discovery/v1" diff --git a/pkg/minikube/sshutil/sshutil.go b/pkg/minikube/sshutil/sshutil.go index a5901f9c7a..291c2e40d3 100644 --- a/pkg/minikube/sshutil/sshutil.go +++ b/pkg/minikube/sshutil/sshutil.go @@ -18,13 +18,13 @@ package sshutil import ( "bufio" + "fmt" "net" "os" "path/filepath" "strconv" "time" - "github.com/pkg/errors" "golang.org/x/crypto/ssh" "golang.org/x/crypto/ssh/knownhosts" "k8s.io/client-go/util/homedir" @@ -39,7 +39,7 @@ import ( func NewSSHClient(d drivers.Driver) (*ssh.Client, error) { h, err := newSSHHost(d) if err != nil { - return nil, errors.Wrap(err, "Error creating new ssh host from driver") + return nil, fmt.Errorf("Error creating new ssh host from driver: %w", err) } defaultKeyPath := filepath.Join(homedir.HomeDir(), ".ssh", "id_rsa") @@ -54,7 +54,7 @@ func NewSSHClient(d drivers.Driver) (*ssh.Client, error) { config, err := machinessh.NewNativeConfig(h.Username, auth) if err != nil { - return nil, errors.Wrapf(err, "Error creating new native config from ssh using: %s, %s", h.Username, auth) + return nil, fmt.Errorf("Error creating new native config from ssh using: %s, %s: %w", h.Username, auth, err) } var client *ssh.Client @@ -84,11 +84,11 @@ func newSSHHost(d drivers.Driver) (*sshHost, error) { ip, err := d.GetSSHHostname() if err != nil { - return nil, errors.Wrap(err, "Error getting ssh host name for driver") + return nil, fmt.Errorf("Error getting ssh host name for driver: %w", err) } port, err := d.GetSSHPort() if err != nil { - return nil, errors.Wrap(err, "Error getting ssh port for driver") + return nil, fmt.Errorf("Error getting ssh port for driver: %w", err) } return &sshHost{ IP: ip, diff --git a/pkg/minikube/storageclass/storageclass.go b/pkg/minikube/storageclass/storageclass.go index 055933d3ae..4282708da7 100644 --- a/pkg/minikube/storageclass/storageclass.go +++ b/pkg/minikube/storageclass/storageclass.go @@ -18,9 +18,9 @@ package storageclass import ( "context" + "fmt" "strconv" - "github.com/pkg/errors" v1 "k8s.io/api/storage/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1" @@ -40,12 +40,12 @@ func annotateDefaultStorageClass(storage storagev1.StorageV1Interface, class *v1 func DisableDefaultStorageClass(storage storagev1.StorageV1Interface, class string) error { sc, err := storage.StorageClasses().Get(context.Background(), class, metav1.GetOptions{}) if err != nil { - return errors.Wrapf(err, "Error getting storage class %s", class) + return fmt.Errorf("Error getting storage class %s: %w", class, err) } err = annotateDefaultStorageClass(storage, sc, false) if err != nil { - return errors.Wrapf(err, "Error marking storage class %s as non-default", class) + return fmt.Errorf("Error marking storage class %s as non-default: %w", class, err) } return nil } @@ -55,7 +55,7 @@ func DisableDefaultStorageClass(storage storagev1.StorageV1Interface, class stri func SetDefaultStorageClass(storage storagev1.StorageV1Interface, name string) error { scList, err := storage.StorageClasses().List(context.Background(), metav1.ListOptions{}) if err != nil { - return errors.Wrap(err, "Error listing StorageClasses") + return fmt.Errorf("Error listing StorageClasses: %w", err) } for _, sc := range scList.Items { err = annotateDefaultStorageClass(storage, &sc, sc.Name == name) @@ -64,7 +64,7 @@ func SetDefaultStorageClass(storage storagev1.StorageV1Interface, name string) e if sc.Name == name { isDefault = "default" } - return errors.Wrapf(err, "Error while marking storage class %s as %s", sc.Name, isDefault) + return fmt.Errorf("Error while marking storage class %s as %s: %w", sc.Name, isDefault, err) } } return nil diff --git a/pkg/minikube/sysinit/openrc.go b/pkg/minikube/sysinit/openrc.go index ed454c8ada..fdb65b76c0 100644 --- a/pkg/minikube/sysinit/openrc.go +++ b/pkg/minikube/sysinit/openrc.go @@ -26,7 +26,6 @@ import ( "path" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/minikube/assets" "k8s.io/minikube/pkg/minikube/vmpath" @@ -202,7 +201,7 @@ func (s *OpenRC) GenerateInitShim(svc string, binary string, unit string) ([]ass var b bytes.Buffer if err := initScriptTmpl.Execute(&b, opts); err != nil { - return nil, errors.Wrap(err, "template execute") + return nil, fmt.Errorf("template execute: %w", err) } files := []assets.CopyableFile{ diff --git a/pkg/minikube/tests/api_mock.go b/pkg/minikube/tests/api_mock.go index 8416ccddb5..127373f5c1 100644 --- a/pkg/minikube/tests/api_mock.go +++ b/pkg/minikube/tests/api_mock.go @@ -22,7 +22,8 @@ import ( "math/rand" "testing" - "github.com/pkg/errors" + "errors" + "github.com/spf13/viper" "k8s.io/minikube/pkg/libmachine/auth" "k8s.io/minikube/pkg/libmachine/host" @@ -72,7 +73,7 @@ func (api *MockAPI) Close() error { func (api *MockAPI) NewHost(drvName string, rawDriver []byte) (*host.Host, error) { var driver MockDriver if err := json.Unmarshal(rawDriver, &driver); err != nil { - return nil, errors.Wrap(err, "error unmarshalling json") + return nil, fmt.Errorf("error unmarshalling json: %w", err) } h := &host.Host{ diff --git a/pkg/minikube/tests/driver_mock.go b/pkg/minikube/tests/driver_mock.go index 4a6862f3dc..25d78eeb94 100644 --- a/pkg/minikube/tests/driver_mock.go +++ b/pkg/minikube/tests/driver_mock.go @@ -20,7 +20,8 @@ import ( "runtime" "testing" - "github.com/pkg/errors" + "errors" + "k8s.io/minikube/pkg/libmachine/drivers" "k8s.io/minikube/pkg/libmachine/mcnflag" "k8s.io/minikube/pkg/libmachine/state" diff --git a/pkg/minikube/tests/ssh_mock.go b/pkg/minikube/tests/ssh_mock.go index 601747177f..18c39eca01 100644 --- a/pkg/minikube/tests/ssh_mock.go +++ b/pkg/minikube/tests/ssh_mock.go @@ -28,7 +28,6 @@ import ( "sync/atomic" "testing" - "github.com/pkg/errors" "golang.org/x/crypto/ssh" ) @@ -62,11 +61,11 @@ func NewSSHServer(t *testing.T) (*SSHServer, error) { private, err := rsa.GenerateKey(rand.Reader, 2014) if err != nil { - return nil, errors.Wrap(err, "Error generating RSA key") + return nil, fmt.Errorf("Error generating RSA key: %w", err) } signer, err := ssh.NewSignerFromKey(private) if err != nil { - return nil, errors.Wrap(err, "Error creating signer from key") + return nil, fmt.Errorf("Error creating signer from key: %w", err) } s.Config.AddHostKey(signer) s.SetSessionRequested(false) @@ -187,7 +186,7 @@ func (s *SSHServer) handleRequest(channel ssh.Channel, req *ssh.Request, wg *syn func (s *SSHServer) Start() (int, error) { l, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { - return 0, errors.Wrap(err, "Error creating tcp listener for ssh server") + return 0, fmt.Errorf("Error creating tcp listener for ssh server: %w", err) } s.listener = l s.t.Logf("Listening on %s", s.listener.Addr()) @@ -195,11 +194,11 @@ func (s *SSHServer) Start() (int, error) { _, p, err := net.SplitHostPort(s.listener.Addr().String()) if err != nil { - return 0, errors.Wrap(err, "Error splitting host port") + return 0, fmt.Errorf("Error splitting host port: %w", err) } port, err := strconv.Atoi(p) if err != nil { - return 0, errors.Wrap(err, "Error converting port string to integer") + return 0, fmt.Errorf("Error converting port string to integer: %w", err) } return port, nil } diff --git a/pkg/minikube/tunnel/cluster_inspector.go b/pkg/minikube/tunnel/cluster_inspector.go index 2879f854b4..fdbe0c83dc 100644 --- a/pkg/minikube/tunnel/cluster_inspector.go +++ b/pkg/minikube/tunnel/cluster_inspector.go @@ -20,7 +20,6 @@ import ( "fmt" "net" - "github.com/pkg/errors" "k8s.io/minikube/pkg/libmachine" "k8s.io/minikube/pkg/libmachine/host" "k8s.io/minikube/pkg/libmachine/state" @@ -40,14 +39,14 @@ func (m *clusterInspector) getStateAndHost() (HostState, *host.Host, error) { h, err := machine.LoadHost(m.machineAPI, m.machineName) if err != nil { - err = errors.Wrapf(err, "error loading machine host for: %s", m.machineName) + err = fmt.Errorf("error loading machine host for: %s: %w", m.machineName, err) return Unknown, nil, err } var s state.State s, err = h.Driver.GetState() if err != nil { - err = errors.Wrapf(err, "error getting host status for %s", m.machineName) + err = fmt.Errorf("error getting host status for %s: %w", m.machineName, err) return Unknown, nil, err } @@ -67,14 +66,14 @@ func (m *clusterInspector) getStateAndRoute() (HostState, *Route, error) { var c *config.ClusterConfig c, err = m.configLoader.LoadConfigFromFile(m.machineName) if err != nil { - err = errors.Wrapf(err, "error loading config for %s", m.machineName) + err = fmt.Errorf("error loading config for %s: %w", m.machineName, err) return hostState, nil, err } var route *Route route, err = getRoute(h, *c) if err != nil { - err = errors.Wrapf(err, "error getting route info for %s", m.machineName) + err = fmt.Errorf("error getting route info for %s: %w", m.machineName, err) return hostState, nil, err } return hostState, route, nil @@ -83,7 +82,7 @@ func (m *clusterInspector) getStateAndRoute() (HostState, *Route, error) { func getRoute(hostInfo *host.Host, clusterConfig config.ClusterConfig) (*Route, error) { hostDriverIP, err := hostInfo.Driver.GetIP() if err != nil { - return nil, errors.Wrapf(err, "error getting host IP for %s", hostInfo.Name) + return nil, fmt.Errorf("error getting host IP for %s: %w", hostInfo.Name, err) } _, ipNet, err := net.ParseCIDR(clusterConfig.KubernetesConfig.ServiceCIDR) diff --git a/pkg/minikube/tunnel/kic/service_tunnel.go b/pkg/minikube/tunnel/kic/service_tunnel.go index aa8997d596..176d003304 100644 --- a/pkg/minikube/tunnel/kic/service_tunnel.go +++ b/pkg/minikube/tunnel/kic/service_tunnel.go @@ -20,8 +20,6 @@ import ( "context" "fmt" - "github.com/pkg/errors" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" typed_core "k8s.io/client-go/kubernetes/typed/core/v1" @@ -61,12 +59,12 @@ func NewServiceTunnel(sshPort, sshKey string, v1Core typed_core.CoreV1Interface, func (t *ServiceTunnel) Start(svcName, namespace string) ([]string, error) { svc, err := t.v1Core.Services(namespace).Get(context.Background(), svcName, metav1.GetOptions{}) if err != nil { - return nil, errors.Wrapf(err, "Service %s was not found in %q namespace. You may select another namespace by using 'minikube service %s -n ", svcName, namespace, svcName) + return nil, fmt.Errorf("Service %s was not found in %q namespace. You may select another namespace by using 'minikube service %s -n : %w", svcName, namespace, svcName, err) } t.sshConn, err = createSSHConnWithRandomPorts(svcName, t.sshPort, t.sshKey, svc) if err != nil { - return nil, errors.Wrap(err, "creating ssh conn") + return nil, fmt.Errorf("creating ssh conn: %w", err) } go func() { diff --git a/pkg/minikube/tunnel/registry.go b/pkg/minikube/tunnel/registry.go index b443df96a4..d55558c9a5 100644 --- a/pkg/minikube/tunnel/registry.go +++ b/pkg/minikube/tunnel/registry.go @@ -22,7 +22,7 @@ import ( "io" "os" - "github.com/pkg/errors" + "errors" "k8s.io/klog/v2" ) diff --git a/pkg/minikube/tunnel/route_darwin.go b/pkg/minikube/tunnel/route_darwin.go index 65891de2df..2ccb0311be 100644 --- a/pkg/minikube/tunnel/route_darwin.go +++ b/pkg/minikube/tunnel/route_darwin.go @@ -25,8 +25,6 @@ import ( "regexp" "strings" - "github.com/pkg/errors" - "k8s.io/klog/v2" ) @@ -188,20 +186,20 @@ func writeResolverFile(route *Route) error { // write resolver content into tf, then copy it to /etc/resolver/clusterDomain tf, err := os.CreateTemp("", "minikube-tunnel-resolver-") if err != nil { - return errors.Wrap(err, "tempfile") + return fmt.Errorf("tempfile: %w", err) } defer os.Remove(tf.Name()) if _, err = tf.WriteString(content); err != nil { - return errors.Wrap(err, "write") + return fmt.Errorf("write: %w", err) } if err = tf.Close(); err != nil { - return errors.Wrap(err, "close") + return fmt.Errorf("close: %w", err) } if err = os.Chmod(tf.Name(), 0644); err != nil { - return errors.Wrap(err, "chmod") + return fmt.Errorf("chmod: %w", err) } cmd := exec.Command("sudo", "mkdir", "-p", filepath.Dir(resolverFile)) @@ -210,7 +208,7 @@ func writeResolverFile(route *Route) error { if exitErr, ok := err.(*exec.ExitError); ok { return fmt.Errorf("%q failed: %v: %q", strings.Join(cmd.Args, " "), exitErr, exitErr.Stderr) } - return errors.Wrap(err, "mkdir") + return fmt.Errorf("mkdir: %w", err) } cmd = exec.Command("sudo", "cp", "-fp", tf.Name(), resolverFile) @@ -220,7 +218,7 @@ func writeResolverFile(route *Route) error { if exitErr, ok := err.(*exec.ExitError); ok { return fmt.Errorf("%q failed: %v: %q", strings.Join(cmd.Args, " "), exitErr, exitErr.Stderr) } - return errors.Wrap(err, "copy") + return fmt.Errorf("copy: %w", err) } klog.Infof("DNS forwarding now configured in %q", resolverFile) return nil diff --git a/pkg/minikube/tunnel/tunnel.go b/pkg/minikube/tunnel/tunnel.go index c087d7bf20..bb301515cd 100644 --- a/pkg/minikube/tunnel/tunnel.go +++ b/pkg/minikube/tunnel/tunnel.go @@ -23,7 +23,6 @@ import ( "os/exec" "regexp" - "github.com/pkg/errors" typed_core "k8s.io/client-go/kubernetes/typed/core/v1" "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine" @@ -99,7 +98,7 @@ func (t *tunnel) cleanup() *Status { klog.V(3).Infof("cleaning up %s", t.status.TunnelID.Route) err := t.router.Cleanup(t.status.TunnelID.Route) if err != nil { - t.status.RouteError = errors.Errorf("error cleaning up route: %v", err) + t.status.RouteError = fmt.Errorf("error cleaning up route: %v", err) klog.V(3).Info(t.status.RouteError.Error()) } else { err = t.registry.Remove(t.status.TunnelID.Route) diff --git a/pkg/minikube/tunnel/tunnel_manager_test.go b/pkg/minikube/tunnel/tunnel_manager_test.go index ea41b2c863..ea6a33af17 100644 --- a/pkg/minikube/tunnel/tunnel_manager_test.go +++ b/pkg/minikube/tunnel/tunnel_manager_test.go @@ -23,7 +23,7 @@ import ( "os" "time" - "github.com/pkg/errors" + "errors" "k8s.io/klog/v2" ) diff --git a/pkg/perf/monitor/execute.go b/pkg/perf/monitor/execute.go index 543ed0114c..c345101e02 100644 --- a/pkg/perf/monitor/execute.go +++ b/pkg/perf/monitor/execute.go @@ -24,20 +24,18 @@ import ( "os" "os/exec" "path/filepath" - - "github.com/pkg/errors" ) // RunMkcmp runs minikube built at the given pr against minikube at master func RunMkcmp(ctx context.Context, pr int) (string, error) { // run 'git pull' so that minikube dir is up to date if _, err := runCmdInMinikube(ctx, []string{"git", "pull", "origin", "master"}); err != nil { - return "", errors.Wrap(err, "running git pull") + return "", fmt.Errorf("running git pull: %w", err) } mkcmpPath := "out/mkcmp" minikubePath := "out/minikube" if _, err := runCmdInMinikube(ctx, []string{"make", mkcmpPath, minikubePath}); err != nil { - return "", errors.Wrap(err, "building minikube and mkcmp at head") + return "", fmt.Errorf("building minikube and mkcmp at head: %w", err) } return runCmdInMinikube(ctx, []string{mkcmpPath, minikubePath, fmt.Sprintf("pr://%d", pr)}) } @@ -53,7 +51,7 @@ func runCmdInMinikube(ctx context.Context, command []string) (string, error) { log.Printf("Running: %v", cmd.Args) if err := cmd.Run(); err != nil { - return "", errors.Wrapf(err, "running %v: %v", cmd.Args, buf.String()) + return "", fmt.Errorf("running %v: %v: %w", cmd.Args, buf.String(), err) } return buf.String(), nil } diff --git a/pkg/perf/monitor/github.go b/pkg/perf/monitor/github.go index 9457e819c4..23f9dc6e27 100644 --- a/pkg/perf/monitor/github.go +++ b/pkg/perf/monitor/github.go @@ -18,12 +18,12 @@ package monitor import ( "context" + "fmt" "log" "os" "time" "github.com/google/go-github/v81/github" - "github.com/pkg/errors" "golang.org/x/oauth2" ) @@ -64,7 +64,7 @@ func (g *Client) CommentOnPR(pr int, message string) error { log.Printf("Creating comment on PR %d: %s", pr, message) _, _, err := g.Issues.CreateComment(g.ctx, g.owner, g.repo, pr, comment) if err != nil { - return errors.Wrap(err, "creating github comment") + return fmt.Errorf("creating github comment: %w", err) } log.Printf("Successfully commented on PR %d.", pr) return nil @@ -75,7 +75,7 @@ func (g *Client) ListOpenPRsWithLabel(label string) ([]int, error) { validPrs := []int{} prs, _, err := g.PullRequests.List(g.ctx, g.owner, g.repo, &github.PullRequestListOptions{}) if err != nil { - return nil, errors.Wrap(err, "listing pull requests") + return nil, fmt.Errorf("listing pull requests: %w", err) } for _, pr := range prs { if prContainsLabel(pr.Labels, label) { @@ -102,11 +102,11 @@ func prContainsLabel(labels []*github.Label, label string) bool { func (g *Client) NewCommitsExist(pr int, login string) (bool, error) { lastCommentTime, err := g.timeOfLastComment(pr, login) if err != nil { - return false, errors.Wrapf(err, "getting time of last comment by %s on pr %d", login, pr) + return false, fmt.Errorf("getting time of last comment by %s on pr %d: %w", login, pr, err) } lastCommitTime, err := g.timeOfLastCommit(pr) if err != nil { - return false, errors.Wrapf(err, "getting time of last commit on pr %d", pr) + return false, fmt.Errorf("getting time of last commit on pr %d: %w", pr, err) } return lastCommentTime.Before(lastCommitTime), nil } diff --git a/pkg/provision/provision.go b/pkg/provision/provision.go index ac07933c21..81767e116e 100644 --- a/pkg/provision/provision.go +++ b/pkg/provision/provision.go @@ -28,7 +28,6 @@ import ( "text/template" "time" - "github.com/pkg/errors" "k8s.io/klog/v2" "k8s.io/minikube/pkg/libmachine/auth" "k8s.io/minikube/pkg/libmachine/cert" @@ -95,12 +94,12 @@ func configureAuth(p miniProvisioner) error { ip, err := driver.GetIP() if err != nil { - return errors.Wrap(err, "error getting ip during provisioning") + return fmt.Errorf("error getting ip during provisioning: %w", err) } hostIP, err := driver.GetSSHHostname() if err != nil { - return errors.Wrap(err, "error getting ssh hostname during provisioning") + return fmt.Errorf("error getting ssh hostname during provisioning: %w", err) } if err := copyHostCerts(authOptions); err != nil { @@ -157,7 +156,7 @@ func copyHostCerts(authOptions auth.Options) error { for src, dst := range hostCerts { f, err := assets.NewFileAsset(src, path.Dir(dst), filepath.Base(dst), "0777") if err != nil { - return errors.Wrapf(err, "open cert file: %s", src) + return fmt.Errorf("open cert file: %s: %w", src, err) } defer func() { if err := f.Close(); err != nil { @@ -166,7 +165,7 @@ func copyHostCerts(authOptions auth.Options) error { }() if err := execRunner.Copy(f); err != nil { - return errors.Wrapf(err, "transferring file: %+v", f) + return fmt.Errorf("transferring file: %+v: %w", f, err) } } @@ -197,7 +196,7 @@ func copyRemoteCerts(authOptions auth.Options, driver drivers.Driver) error { for src, dst := range remoteCerts { f, err := assets.NewFileAsset(src, path.Dir(dst), filepath.Base(dst), "0640") if err != nil { - return errors.Wrapf(err, "error copying %s to %s", src, dst) + return fmt.Errorf("error copying %s to %s: %w", src, dst, err) } defer func() { if err := f.Close(); err != nil { @@ -206,7 +205,7 @@ func copyRemoteCerts(authOptions auth.Options, driver drivers.Driver) error { }() if err := sshRunner.Copy(f); err != nil { - return errors.Wrapf(err, "transferring file to machine %v", f) + return fmt.Errorf("transferring file to machine %v: %w", f, err) } } @@ -229,7 +228,7 @@ func setRemoteAuthOptions(p provision.Provisioner) auth.Options { func setContainerRuntimeOptions(name string, p miniProvisioner) error { c, err := config.Load(name) if err != nil { - return errors.Wrap(err, "getting cluster config") + return fmt.Errorf("getting cluster config: %w", err) } switch c.KubernetesConfig.ContainerRuntime { diff --git a/pkg/storage/storage_provisioner.go b/pkg/storage/storage_provisioner.go index 35ce2affc0..27d1075ddc 100644 --- a/pkg/storage/storage_provisioner.go +++ b/pkg/storage/storage_provisioner.go @@ -22,7 +22,7 @@ import ( "os" "path" - "github.com/pkg/errors" + "errors" core "k8s.io/api/core/v1" meta "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -105,7 +105,7 @@ func (p *hostPathProvisioner) Delete(_ context.Context, volume *core.PersistentV } if err := os.RemoveAll(volume.Spec.HostPath.Path); err != nil { - return errors.Wrap(err, "removing hostpath PV") + return fmt.Errorf("removing hostpath PV: %w", err) } return nil diff --git a/pkg/trace/gcp.go b/pkg/trace/gcp.go index e4677f9acd..20e5a17441 100644 --- a/pkg/trace/gcp.go +++ b/pkg/trace/gcp.go @@ -27,7 +27,6 @@ import ( "k8s.io/klog/v2" texporter "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace" - "github.com/pkg/errors" ) const ( @@ -84,7 +83,7 @@ func initGCPTracer() (*gcpTracer, error) { texporter.WithProjectID(projectID), }...) if err != nil { - return nil, errors.Wrap(err, "installing pipeline") + return nil, fmt.Errorf("installing pipeline: %w", err) } tp := sdktrace.NewTracerProvider( diff --git a/pkg/trace/trace.go b/pkg/trace/trace.go index fca85c8e5e..39ba864adc 100644 --- a/pkg/trace/trace.go +++ b/pkg/trace/trace.go @@ -18,8 +18,6 @@ package trace import ( "fmt" - - "github.com/pkg/errors" ) var ( @@ -36,7 +34,7 @@ type minikubeTracer interface { func Initialize(t string) error { tr, err := getTracer(t) if err != nil { - return errors.Wrap(err, "getting tracer") + return fmt.Errorf("getting tracer: %w", err) } tracer = tr return nil diff --git a/pkg/util/constants.go b/pkg/util/constants.go index db1a39c056..8068a1788e 100644 --- a/pkg/util/constants.go +++ b/pkg/util/constants.go @@ -17,9 +17,8 @@ limitations under the License. package util import ( + "fmt" "net" - - "github.com/pkg/errors" ) // DefaultAdmissionControllers are admission controllers we default to @@ -39,7 +38,7 @@ var DefaultAdmissionControllers = []string{ func ServiceClusterIP(serviceCIDR string) (net.IP, error) { ip, _, err := net.ParseCIDR(serviceCIDR) if err != nil { - return nil, errors.Wrap(err, "parsing default service cidr") + return nil, fmt.Errorf("parsing default service cidr: %w", err) } ip = ip.To4() ip[3]++ @@ -50,7 +49,7 @@ func ServiceClusterIP(serviceCIDR string) (net.IP, error) { func DNSIP(serviceCIDR string) (net.IP, error) { ip, _, err := net.ParseCIDR(serviceCIDR) if err != nil { - return nil, errors.Wrap(err, "parsing default service cidr") + return nil, fmt.Errorf("parsing default service cidr: %w", err) } ip = ip.To4() ip[3] = 10 diff --git a/pkg/util/crypto.go b/pkg/util/crypto.go index 96151cf470..ea3795429b 100644 --- a/pkg/util/crypto.go +++ b/pkg/util/crypto.go @@ -23,13 +23,15 @@ import ( "crypto/x509" "crypto/x509/pkix" "encoding/pem" + "fmt" "math/big" "net" "os" "path/filepath" "time" - "github.com/pkg/errors" + "errors" + "k8s.io/klog/v2" "k8s.io/minikube/pkg/util/lock" ) @@ -38,7 +40,7 @@ import ( func GenerateCACert(certPath, keyPath string, name string) error { priv, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { - return errors.Wrap(err, "Error generating rsa key") + return fmt.Errorf("Error generating rsa key: %w", err) } template := x509.Certificate{ @@ -68,7 +70,7 @@ func GenerateSignedCert(certPath, keyPath, cn string, ips []net.IP, alternateDNS klog.Infof("Generating cert %s with IP's: %s", certPath, ips) signerCertBytes, err := os.ReadFile(signerCertPath) if err != nil { - return errors.Wrap(err, "Error reading file: signerCertPath") + return fmt.Errorf("Error reading file: signerCertPath: %w", err) } decodedSignerCert, _ := pem.Decode(signerCertBytes) if decodedSignerCert == nil { @@ -76,11 +78,11 @@ func GenerateSignedCert(certPath, keyPath, cn string, ips []net.IP, alternateDNS } signerCert, err := x509.ParseCertificate(decodedSignerCert.Bytes) if err != nil { - return errors.Wrap(err, "Error parsing certificate: decodedSignerCert.Bytes") + return fmt.Errorf("Error parsing certificate: decodedSignerCert.Bytes: %w", err) } signerKeyBytes, err := os.ReadFile(signerKeyPath) if err != nil { - return errors.Wrap(err, "Error reading file: signerKeyPath") + return fmt.Errorf("Error reading file: signerKeyPath: %w", err) } decodedSignerKey, _ := pem.Decode(signerKeyBytes) if decodedSignerKey == nil { @@ -88,7 +90,7 @@ func GenerateSignedCert(certPath, keyPath, cn string, ips []net.IP, alternateDNS } signerKey, err := x509.ParsePKCS1PrivateKey(decodedSignerKey.Bytes) if err != nil { - return errors.Wrap(err, "Error parsing private key: decodedSignerKey.Bytes") + return fmt.Errorf("Error parsing private key: decodedSignerKey.Bytes: %w", err) } template := x509.Certificate{ @@ -110,7 +112,7 @@ func GenerateSignedCert(certPath, keyPath, cn string, ips []net.IP, alternateDNS priv, err := loadOrGeneratePrivateKey(keyPath) if err != nil { - return errors.Wrap(err, "Error loading or generating private key: keyPath") + return fmt.Errorf("Error loading or generating private key: keyPath: %w", err) } return writeCertsAndKeys(&template, certPath, priv, keyPath, signerCert, signerKey) @@ -129,7 +131,7 @@ func loadOrGeneratePrivateKey(keyPath string) (*rsa.PrivateKey, error) { } priv, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { - return nil, errors.Wrap(err, "Error generating RSA key") + return nil, fmt.Errorf("Error generating RSA key: %w", err) } return priv, nil } @@ -137,33 +139,33 @@ func loadOrGeneratePrivateKey(keyPath string) (*rsa.PrivateKey, error) { func writeCertsAndKeys(template *x509.Certificate, certPath string, signeeKey *rsa.PrivateKey, keyPath string, parent *x509.Certificate, signingKey *rsa.PrivateKey) error { derBytes, err := x509.CreateCertificate(rand.Reader, template, parent, &signeeKey.PublicKey, signingKey) if err != nil { - return errors.Wrap(err, "Error creating certificate") + return fmt.Errorf("Error creating certificate: %w", err) } certBuffer := bytes.Buffer{} if err := pem.Encode(&certBuffer, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes}); err != nil { - return errors.Wrap(err, "Error encoding certificate") + return fmt.Errorf("Error encoding certificate: %w", err) } keyBuffer := bytes.Buffer{} if err := pem.Encode(&keyBuffer, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(signeeKey)}); err != nil { - return errors.Wrap(err, "Error encoding key") + return fmt.Errorf("Error encoding key: %w", err) } if err := os.MkdirAll(filepath.Dir(certPath), os.FileMode(0755)); err != nil { - return errors.Wrap(err, "Error creating certificate directory") + return fmt.Errorf("Error creating certificate directory: %w", err) } klog.Infof("Writing cert to %s ...", certPath) if err := lock.WriteFile(certPath, certBuffer.Bytes(), os.FileMode(0644)); err != nil { - return errors.Wrap(err, "Error writing certificate to cert path") + return fmt.Errorf("Error writing certificate to cert path: %w", err) } if err := os.MkdirAll(filepath.Dir(keyPath), os.FileMode(0755)); err != nil { - return errors.Wrap(err, "Error creating key directory") + return fmt.Errorf("Error creating key directory: %w", err) } klog.Infof("Writing key to %s ...", keyPath) if err := lock.WriteFile(keyPath, keyBuffer.Bytes(), os.FileMode(0600)); err != nil { - return errors.Wrap(err, "Error writing key file") + return fmt.Errorf("Error writing key file: %w", err) } return nil diff --git a/pkg/util/lock/lock.go b/pkg/util/lock/lock.go index e8880ec654..fb242e618d 100644 --- a/pkg/util/lock/lock.go +++ b/pkg/util/lock/lock.go @@ -24,8 +24,9 @@ import ( "path/filepath" "time" + "errors" + "github.com/gofrs/flock" - "github.com/pkg/errors" "k8s.io/klog/v2" ) @@ -59,7 +60,7 @@ func WriteFile(filename string, data []byte, perm os.FileMode) error { klog.Infof("WriteFile acquiring %s: %+v", filename, spec) releaser, err := Acquire(spec) if err != nil { - return errors.Wrapf(err, "failed to acquire lock for %s: %+v", filename, spec) + return fmt.Errorf("failed to acquire lock for %s: %+v: %w", filename, spec, err) } defer releaser.Release() @@ -74,14 +75,14 @@ func AppendToFile(filename string, data []byte, perm os.FileMode) error { klog.Infof("WriteFile acquiring %s: %+v", filename, spec) releaser, err := Acquire(spec) if err != nil { - return errors.Wrapf(err, "failed to acquire lock for %s: %+v", filename, spec) + return fmt.Errorf("failed to acquire lock for %s: %+v: %w", filename, spec, err) } defer releaser.Release() fd, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, perm) if err != nil { - return errors.Wrapf(err, "failed to open %s: %+v", filename, spec) + return fmt.Errorf("failed to open %s: %+v: %w", filename, spec, err) } _, err = fd.Write(data) @@ -103,7 +104,7 @@ func Acquire(spec Spec) (Releaser, error) { tmpDir := os.TempDir() lockDir := filepath.Join(tmpDir, "minikube-locks") if err := os.MkdirAll(lockDir, 0755); err != nil { - return nil, errors.Wrap(err, "creating lock dir") + return nil, fmt.Errorf("creating lock dir: %w", err) } lockPath := filepath.Join(lockDir, spec.Name+".lock") @@ -116,13 +117,13 @@ func Acquire(spec Spec) (Releaser, error) { locked, err := f.TryLockContext(ctx, spec.Delay) if err != nil { if errors.Is(err, context.DeadlineExceeded) { - return nil, errors.Errorf("timed out waiting for lock %s", spec.Name) + return nil, fmt.Errorf("timed out waiting for lock %s", spec.Name) } - return nil, errors.Wrap(err, "acquiring lock") + return nil, fmt.Errorf("acquiring lock: %w", err) } if !locked { - return nil, errors.Errorf("failed to acquire lock %s", spec.Name) + return nil, fmt.Errorf("failed to acquire lock %s", spec.Name) } return &flockReleaser{f: f}, nil diff --git a/pkg/util/utils.go b/pkg/util/utils.go index e7a6a7dc10..ce68dbad02 100644 --- a/pkg/util/utils.go +++ b/pkg/util/utils.go @@ -25,7 +25,6 @@ import ( "github.com/blang/semver/v4" units "github.com/docker/go-units" - "github.com/pkg/errors" ) const ( @@ -88,18 +87,18 @@ func MaybeChownDirRecursiveToMinikubeUser(dir string) error { username := os.Getenv("SUDO_USER") usr, err := user.Lookup(username) if err != nil { - return errors.Wrap(err, "Error looking up user") + return fmt.Errorf("Error looking up user: %w", err) } uid, err := strconv.Atoi(usr.Uid) if err != nil { - return errors.Wrapf(err, "Error parsing uid for user: %s", username) + return fmt.Errorf("Error parsing uid for user: %s: %w", username, err) } gid, err := strconv.Atoi(usr.Gid) if err != nil { - return errors.Wrapf(err, "Error parsing gid for user: %s", username) + return fmt.Errorf("Error parsing gid for user: %s: %w", username, err) } if err := ChownR(dir, uid, gid); err != nil { - return errors.Wrapf(err, "Error changing ownership for: %s", dir) + return fmt.Errorf("Error changing ownership for: %s: %w", dir, err) } } return nil diff --git a/test/integration/functional_test.go b/test/integration/functional_test.go index e4c67be1e7..a61d475b5c 100644 --- a/test/integration/functional_test.go +++ b/test/integration/functional_test.go @@ -54,7 +54,6 @@ import ( "github.com/hashicorp/go-retryablehttp" cp "github.com/otiai10/copy" "github.com/phayes/freeport" - "github.com/pkg/errors" "golang.org/x/build/kubernetes/api" "k8s.io/minikube/pkg/minikube/cruntime" ) @@ -2144,7 +2143,7 @@ func startProxyWithCustomCerts(ctx context.Context, t *testing.T) error { // Download the mitmproxy bundle for mitmdump _, err := Run(t, exec.CommandContext(ctx, "curl", "-LO", "https://snapshots.mitmproxy.org/6.0.2/mitmproxy-6.0.2-linux.tar.gz")) if err != nil { - return errors.Wrap(err, "download mitmproxy tar") + return fmt.Errorf("download mitmproxy tar: %w", err) } defer func() { err := os.Remove("mitmproxy-6.0.2-linux.tar.gz") @@ -2157,14 +2156,14 @@ func startProxyWithCustomCerts(ctx context.Context, t *testing.T) error { _, err = Run(t, exec.CommandContext(ctx, "tar", "xzf", "mitmproxy-6.0.2-linux.tar.gz", "-C", mitmDir)) if err != nil { - return errors.Wrap(err, "untar mitmproxy tar") + return fmt.Errorf("untar mitmproxy tar: %w", err) } // Start mitmdump in the background, this will create the needed certs // and provide the necessary proxy at 127.0.0.1:8080 mitmRR, err := Start(t, exec.CommandContext(ctx, path.Join(mitmDir, "mitmdump"), "--set", fmt.Sprintf("confdir=%s", mitmDir))) if err != nil { - return errors.Wrap(err, "starting mitmproxy") + return fmt.Errorf("starting mitmproxy: %w", err) } // Store it for cleanup later @@ -2184,26 +2183,26 @@ func startProxyWithCustomCerts(ctx context.Context, t *testing.T) error { _, err = os.Stat(certFile) } if os.IsNotExist(err) { - return errors.Wrap(err, "cert files never showed up") + return fmt.Errorf("cert files never showed up: %w", err) } destCertPath := path.Join("/etc/ssl/certs", "mitmproxy-ca-cert.pem") symLinkCmd := fmt.Sprintf("ln -fs %s %s", certFile, destCertPath) if _, err := Run(t, exec.CommandContext(ctx, "sudo", "/bin/bash", "-c", symLinkCmd)); err != nil { - return errors.Wrap(err, "cert symlink") + return fmt.Errorf("cert symlink: %w", err) } // Add a symlink of the form {hash}.0 rr, err := Run(t, exec.CommandContext(ctx, "openssl", "x509", "-hash", "-noout", "-in", certFile)) if err != nil { - return errors.Wrap(err, "cert hashing") + return fmt.Errorf("cert hashing: %w", err) } stringHash := strings.TrimSpace(rr.Stdout.String()) hashLink := path.Join("/etc/ssl/certs", fmt.Sprintf("%s.0", stringHash)) hashCmd := fmt.Sprintf("test -L %s || ln -fs %s %s", hashLink, destCertPath, hashLink) if _, err := Run(t, exec.CommandContext(ctx, "sudo", "/bin/bash", "-c", hashCmd)); err != nil { - return errors.Wrap(err, "cert hash symlink") + return fmt.Errorf("cert hash symlink: %w", err) } return nil @@ -2213,7 +2212,7 @@ func startProxyWithCustomCerts(ctx context.Context, t *testing.T) error { func startHTTPProxy(t *testing.T) (*http.Server, error) { port, err := freeport.GetFreePort() if err != nil { - return nil, errors.Wrap(err, "Failed to get an open port") + return nil, fmt.Errorf("Failed to get an open port: %w", err) } addr := fmt.Sprintf("localhost:%d", port) diff --git a/test/integration/functional_test_tunnel_test.go b/test/integration/functional_test_tunnel_test.go index b41753d216..3b3890b58f 100644 --- a/test/integration/functional_test_tunnel_test.go +++ b/test/integration/functional_test_tunnel_test.go @@ -33,8 +33,6 @@ import ( "k8s.io/apimachinery/pkg/util/wait" - "github.com/pkg/errors" - "k8s.io/minikube/pkg/kapi" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/detect" @@ -218,7 +216,7 @@ func validateServiceStable(ctx context.Context, t *testing.T, profile string) { } if err := kapi.WaitForService(client, "default", "nginx-svc", true, 1*time.Second, Minutes(2)); err != nil { - t.Fatal(errors.Wrap(err, "Error waiting for nginx service to be up")) + t.Fatal(fmt.Errorf("Error waiting for nginx service to be up: %w", err)) } }) if !setupSucceeded { diff --git a/third_party/kubeadm/app/constants/constants.go b/third_party/kubeadm/app/constants/constants.go index fe76720c74..2af323162d 100644 --- a/third_party/kubeadm/app/constants/constants.go +++ b/third_party/kubeadm/app/constants/constants.go @@ -31,7 +31,7 @@ import ( bootstrapapi "k8s.io/cluster-bootstrap/token/api" utilnet "k8s.io/utils/net" - "github.com/pkg/errors" + "errors" ) const ( @@ -560,12 +560,12 @@ func CreateTempDirForKubeadm(kubernetesDir, dirName string) (string, error) { // creates target folder if not already exists if err := os.MkdirAll(tempDir, 0700); err != nil { - return "", errors.Wrapf(err, "failed to create directory %q", tempDir) + return "", fmt.Errorf("failed to create directory %q: %w", tempDir, err) } tempDir, err := os.MkdirTemp(tempDir, dirName) if err != nil { - return "", errors.Wrap(err, "couldn't create a temporary directory") + return "", fmt.Errorf("couldn't create a temporary directory: %w", err) } return tempDir, nil } @@ -579,13 +579,13 @@ func CreateTimestampDirForKubeadm(kubernetesDir, dirName string) (string, error) // creates target folder if not already exists if err := os.MkdirAll(tempDir, 0700); err != nil { - return "", errors.Wrapf(err, "failed to create directory %q", tempDir) + return "", fmt.Errorf("failed to create directory %q: %w", tempDir, err) } timestampDirName := fmt.Sprintf("%s-%s", dirName, time.Now().Format("2006-01-02-15-04-05")) timestampDir := path.Join(tempDir, timestampDirName) if err := os.Mkdir(timestampDir, 0700); err != nil { - return "", errors.Wrap(err, "could not create timestamp directory") + return "", fmt.Errorf("could not create timestamp directory: %w", err) } return timestampDir, nil @@ -596,13 +596,13 @@ func GetDNSIP(svcSubnetList string, isDualStack bool) (net.IP, error) { // Get the service subnet CIDR svcSubnetCIDR, err := GetKubernetesServiceCIDR(svcSubnetList, isDualStack) if err != nil { - return nil, errors.Wrapf(err, "unable to get internal Kubernetes Service IP from the given service CIDR (%s)", svcSubnetList) + return nil, fmt.Errorf("unable to get internal Kubernetes Service IP from the given service CIDR (%s): %w", svcSubnetList, err) } // Selects the 10th IP in service subnet CIDR range as dnsIP dnsIP, err := utilnet.GetIndexedIP(svcSubnetCIDR, 10) if err != nil { - return nil, errors.Wrap(err, "unable to get internal Kubernetes Service IP from the given service CIDR") + return nil, fmt.Errorf("unable to get internal Kubernetes Service IP from the given service CIDR: %w", err) } return dnsIP, nil @@ -616,7 +616,7 @@ func GetKubernetesServiceCIDR(svcSubnetList string, isDualStack bool) (*net.IPNe // of the kube-controller-manager and kube-apiserver. svcSubnets, err := utilnet.ParseCIDRs(strings.Split(svcSubnetList, ",")) if err != nil { - return nil, errors.Wrapf(err, "unable to parse ServiceSubnet %v", svcSubnetList) + return nil, fmt.Errorf("unable to parse ServiceSubnet %v: %w", svcSubnetList, err) } if len(svcSubnets) == 0 { return nil, errors.New("received empty ServiceSubnet for dual-stack") @@ -626,7 +626,7 @@ func GetKubernetesServiceCIDR(svcSubnetList string, isDualStack bool) (*net.IPNe // internal IP address for the API server _, svcSubnet, err := net.ParseCIDR(svcSubnetList) if err != nil { - return nil, errors.Wrapf(err, "unable to parse ServiceSubnet %v", svcSubnetList) + return nil, fmt.Errorf("unable to parse ServiceSubnet %v: %w", svcSubnetList, err) } return svcSubnet, nil } @@ -635,11 +635,11 @@ func GetKubernetesServiceCIDR(svcSubnetList string, isDualStack bool) (*net.IPNe func GetAPIServerVirtualIP(svcSubnetList string, isDualStack bool) (net.IP, error) { svcSubnet, err := GetKubernetesServiceCIDR(svcSubnetList, isDualStack) if err != nil { - return nil, errors.Wrap(err, "unable to get internal Kubernetes Service IP from the given service CIDR") + return nil, fmt.Errorf("unable to get internal Kubernetes Service IP from the given service CIDR: %w", err) } internalAPIServerVirtualIP, err := utilnet.GetIndexedIP(svcSubnet, 1) if err != nil { - return nil, errors.Wrapf(err, "unable to get the first IP address from the given CIDR: %s", svcSubnet.String()) + return nil, fmt.Errorf("unable to get the first IP address from the given CIDR: %s: %w", svcSubnet.String(), err) } return internalAPIServerVirtualIP, nil } diff --git a/third_party/kubeadm/app/features/features.go b/third_party/kubeadm/app/features/features.go index a392f40faa..ac9420783c 100644 --- a/third_party/kubeadm/app/features/features.go +++ b/third_party/kubeadm/app/features/features.go @@ -24,8 +24,6 @@ import ( "k8s.io/apimachinery/pkg/util/version" "k8s.io/component-base/featuregate" - - "github.com/pkg/errors" ) const ( @@ -62,12 +60,12 @@ func ValidateVersion(allFeatures FeatureList, requestedFeatures map[string]bool, } parsedExpVersion, err := version.ParseSemantic(requestedVersion) if err != nil { - return errors.Wrapf(err, "error parsing version %s", requestedVersion) + return fmt.Errorf("error parsing version %s: %w", requestedVersion, err) } for k := range requestedFeatures { if minVersion := allFeatures[k].MinimumVersion; minVersion != nil { if !parsedExpVersion.AtLeast(minVersion) { - return errors.Errorf( + return fmt.Errorf( "the requested Kubernetes version (%s) is incompatible with the %s feature gate, which needs %s as a minimum", requestedVersion, k, minVersion) } @@ -133,7 +131,7 @@ func NewFeatureGate(f *FeatureList, value string) (map[string]bool, error) { arr := strings.SplitN(s, "=", 2) if len(arr) != 2 { - return nil, errors.Errorf("missing bool value for feature-gate key:%s", s) + return nil, fmt.Errorf("missing bool value for feature-gate key:%s", s) } k := strings.TrimSpace(arr[0]) @@ -141,16 +139,16 @@ func NewFeatureGate(f *FeatureList, value string) (map[string]bool, error) { featureSpec, ok := (*f)[k] if !ok { - return nil, errors.Errorf("unrecognized feature-gate key: %s", k) + return nil, fmt.Errorf("unrecognized feature-gate key: %s", k) } if featureSpec.PreRelease == featuregate.Deprecated { - return nil, errors.Errorf("feature-gate key is deprecated: %s", k) + return nil, fmt.Errorf("feature-gate key is deprecated: %s", k) } boolValue, err := strconv.ParseBool(v) if err != nil { - return nil, errors.Errorf("invalid value %v for feature-gate key: %s, use true|false instead", v, k) + return nil, fmt.Errorf("invalid value %v for feature-gate key: %s, use true|false instead", v, k) } featureGate[k] = boolValue }