From dd7d57ef45e8a27927779be0807e8ca857576a2c Mon Sep 17 00:00:00 2001 From: Debanitrkl <118bm0622@nitrkl.ac.in> Date: Wed, 15 Jun 2022 22:21:09 +0530 Subject: [PATCH 1/6] changed to golang native error wrapping --- cmd/krel/cmd/announce_build.go | 13 ++- cmd/krel/cmd/announce_send.go | 18 ++-- cmd/krel/cmd/cve.go | 21 ++-- cmd/krel/cmd/push.go | 3 +- cmd/krel/cmd/release.go | 3 +- cmd/krel/cmd/release_notes.go | 182 ++++++++++++++++----------------- cmd/krel/cmd/testgrid.go | 34 +++--- 7 files changed, 135 insertions(+), 139 deletions(-) diff --git a/cmd/krel/cmd/announce_build.go b/cmd/krel/cmd/announce_build.go index d5bf47df82e..96145941007 100644 --- a/cmd/krel/cmd/announce_build.go +++ b/cmd/krel/cmd/announce_build.go @@ -177,7 +177,7 @@ func runBuildBranchAnnounce(opts *buildBranchAnnounceOptions, buildOpts *buildAn if err := t.Execute(&annoucement, struct { Branch string }{opts.branch}); err != nil { - return errors.Wrap(err, "generating the announcement html file") + return fmt.Errorf("generating the announcement html file: %w", err) } announcementSubject := fmt.Sprintf("Kubernetes %s branch has been created", opts.branch) @@ -187,7 +187,7 @@ func runBuildBranchAnnounce(opts *buildBranchAnnounceOptions, buildOpts *buildAn // runBuildReleaseAnnounce build the announcement file when creating a new Kubernetes release func runBuildReleaseAnnounce(opts *buildReleaseAnnounceOptions, buildOpts *buildAnnounceOptions, announceOpts *announceOptions) error { if err := announceOpts.Validate(); err != nil { - return errors.Wrap(err, "validating annoucement send options") + return fmt.Errorf("validating annoucement send options: %w", err) } logrus.Info("Building release announcement for new release") @@ -223,7 +223,7 @@ func runBuildReleaseAnnounce(opts *buildReleaseAnnounceOptions, buildOpts *build filepath.Base(opts.changelogFilePath), string(changelogHTML), }); err != nil { - return errors.Wrap(err, "generating the announcement html file") + return fmt.Errorf("generating the announcement html file: %w", err) } announcementSubject := fmt.Sprintf("Kubernetes %s is live!", announceOpts.tag) @@ -238,15 +238,14 @@ func (opts *buildAnnounceOptions) saveAnnouncement(announcementSubject string, a logrus.Infof("Writing HTML file to %s", absOutputPath) err := os.WriteFile(absOutputPath, annoucement.Bytes(), os.FileMode(0o644)) if err != nil { - return errors.Wrap(err, "saving announcement.html") + return fmt.Errorf("saving announcement.html: %w", err) } absOutputPath = filepath.Join(opts.workDir, "announcement-subject.txt") logrus.Infof("Writing announcement subject to %s", absOutputPath) err = os.WriteFile(absOutputPath, []byte(announcementSubject), os.FileMode(0o644)) if err != nil { - return errors.Wrap(err, "saving announcement-subject.txt") - } + return fmt.Errorf("saving announcement-subject.txt: %w", err) logrus.Info("Kubernetes Announcement created.") return nil @@ -257,7 +256,7 @@ func getGoVersion() (string, error) { "go", "version"). RunSilentSuccessOutput() if err != nil { - return "", errors.Wrap(err, "get go version") + return "", fmt.Errorf("get go version: %w", err) } versionRegex := regexp.MustCompile(semVerRegex) diff --git a/cmd/krel/cmd/announce_send.go b/cmd/krel/cmd/announce_send.go index a766baa95db..fa66e1d2aa7 100644 --- a/cmd/krel/cmd/announce_send.go +++ b/cmd/krel/cmd/announce_send.go @@ -17,9 +17,9 @@ limitations under the License. package cmd import ( + "errors" "fmt" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/spf13/cobra" @@ -110,7 +110,7 @@ func init() { func runAnnounce(opts *sendAnnounceOptions, announceRootOpts *announceOptions, rootOpts *rootOptions) error { if err := announceRootOpts.Validate(); err != nil { - return errors.Wrap(err, "validating annoucement send options") + return fmt.Errorf("validating annoucement send options: %w", err) } logrus.Info("Retrieving release announcement from Google Cloud Bucket") @@ -123,8 +123,8 @@ func runAnnounce(opts *sendAnnounceOptions, announceRootOpts *announceOptions, r content, err := http.GetURLResponse(u, false) if err != nil { - return errors.Wrapf(err, - "unable to retrieve release announcement form url: %s", u, + return fmt.Errorf( + "unable to retrieve release announcement form url: %s: %w", u, err, ) } @@ -135,7 +135,7 @@ func runAnnounce(opts *sendAnnounceOptions, announceRootOpts *announceOptions, r } if opts.sendgridAPIKey == "" { - return errors.Errorf( + return fmt.Errorf( "$%s is not set", sendgridAPIKeyEnvKey, ) } @@ -145,12 +145,12 @@ func runAnnounce(opts *sendAnnounceOptions, announceRootOpts *announceOptions, r if opts.name != "" && opts.email != "" { if err := m.SetSender(opts.name, opts.email); err != nil { - return errors.Wrap(err, "unable to set mail sender") + return fmt.Errorf("unable to set mail sender: %w", err) } } else { logrus.Info("Retrieving default sender from sendgrid API") if err := m.SetDefaultSender(); err != nil { - return errors.Wrap(err, "setting default sender") + return fmt.Errorf("setting default sender: %w", err) } } @@ -164,7 +164,7 @@ func runAnnounce(opts *sendAnnounceOptions, announceRootOpts *announceOptions, r logrus.Infof("Using Google Groups as announcement target: %v", groups) if err := m.SetGoogleGroupRecipients(groups...); err != nil { - return errors.Wrap(err, "unable to set mail recipients") + return fmt.Errorf("unable to set mail recipients: %w", err) } logrus.Info("Sending mail") @@ -181,7 +181,7 @@ func runAnnounce(opts *sendAnnounceOptions, announceRootOpts *announceOptions, r if yes { if err := m.Send(content, subject); err != nil { - return errors.Wrap(err, "unable to send mail") + return fmt.Errorf("unable to send mail: %w", err) } } diff --git a/cmd/krel/cmd/cve.go b/cmd/krel/cmd/cve.go index fae25749974..b1ed7c2cdd4 100644 --- a/cmd/krel/cmd/cve.go +++ b/cmd/krel/cmd/cve.go @@ -18,10 +18,11 @@ package cmd import ( "bytes" + "errors" + "fmt" "os" "strings" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/spf13/cobra" @@ -87,7 +88,7 @@ var argFunc = func(cmd *cobra.Command, args []string) error { } cveOpts.CVE = strings.ToUpper(args[0]) if err := cve.NewClient().CheckID(cveOpts.CVE); err != nil { - return errors.Errorf("invalid CVE ID. Format must match %s", cve.CVEIDRegExp) + return fmt.Errorf("invalid CVE ID. Format must match %s", cve.CVEIDRegExp) } return nil } @@ -113,12 +114,12 @@ func writeNewCVE(opts *cveOptions) (err error) { file, err := client.CreateEmptyMap(opts.CVE) if err != nil { - return errors.Wrap(err, "creating new cve data map") + return fmt.Errorf("creating new cve data map: %w", err) } oldFile, err := os.ReadFile(file.Name()) if err != nil { - return errors.Wrap(err, "reading local copy of CVE entry") + return fmt.Errorf("reading local copy of CVE entry: %w", err) } kubeEditor := editor.NewDefaultEditor([]string{"KUBE_EDITOR", "EDITOR"}) @@ -126,7 +127,7 @@ func writeNewCVE(opts *cveOptions) (err error) { "cve-datamap-", ".yaml", bytes.NewReader(oldFile), ) if err != nil { - return errors.Wrap(err, "launching editor") + return fmt.Errorf("launching editor: %w", err) } if bytes.Equal(changes, oldFile) || len(changes) == 0 { @@ -145,7 +146,7 @@ func writeCVEFiles(opts *cveOptions) error { client := cve.NewClient() for _, mapFile := range opts.mapFiles { if err := client.Write(opts.CVE, mapFile); err != nil { - return errors.Wrapf(err, "writing map file %s", mapFile) + return fmt.Errorf("writing map file %s: %w", mapFile, err) } } return nil @@ -170,7 +171,7 @@ func editCVE(opts *cveOptions) (err error) { // or we should first pull the data from the bucket exists, err := client.EntryExists(opts.CVE) if err != nil { - return errors.Wrap(err, "checking if cve entry exists") + return fmt.Errorf("checking if cve entry exists: %w", err) } if exists { @@ -186,11 +187,11 @@ func editExistingCVE(opts *cveOptions) (err error) { client := cve.NewClient() file, err := client.CopyToTemp(opts.CVE) if err != nil { - return errors.Wrap(err, "copying CVE entry for edting") + return fmt.Errorf("copying CVE entry for edting: %w", err) } oldFile, err := os.ReadFile(file.Name()) if err != nil { - return errors.Wrap(err, "reading local copy of CVE entry") + return fmt.Errorf("reading local copy of CVE entry: %w", err) } kubeEditor := editor.NewDefaultEditor([]string{"KUBE_EDITOR", "EDITOR"}) @@ -198,7 +199,7 @@ func editExistingCVE(opts *cveOptions) (err error) { "cve-datamap-", ".yaml", bytes.NewReader(oldFile), ) if err != nil { - return errors.Wrap(err, "launching editor") + return fmt.Errorf("launching editor: %w", err) } if bytes.Equal(changes, oldFile) || len(changes) == 0 { diff --git a/cmd/krel/cmd/push.go b/cmd/krel/cmd/push.go index 0cab0167fe1..942d261d5f0 100644 --- a/cmd/krel/cmd/push.go +++ b/cmd/krel/cmd/push.go @@ -19,7 +19,6 @@ package cmd import ( "fmt" - "github.com/pkg/errors" "github.com/spf13/cobra" "k8s.io/release/pkg/build" @@ -51,7 +50,7 @@ var pushBuildCmd = &cobra.Command{ SilenceErrors: true, RunE: func(cmd *cobra.Command, args []string) error { if err := runPushBuild(pushBuildOpts); err != nil { - return errors.Wrap(err, "failed to run") + return fmt.Errorf("failed to run: %w", err) } return nil diff --git a/cmd/krel/cmd/release.go b/cmd/krel/cmd/release.go index 4060d8b4d93..2bff1ce1331 100644 --- a/cmd/krel/cmd/release.go +++ b/cmd/krel/cmd/release.go @@ -20,7 +20,6 @@ import ( "fmt" "strings" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/spf13/cobra" @@ -138,7 +137,7 @@ func runRelease(options *anago.ReleaseOptions) error { // Perform a local check of the specified options // before launching a Cloud Build job: if err := options.Validate(&anago.State{}); err != nil { - return errors.Wrap(err, "prechecking release options") + return fmt.Errorf("prechecking release options: %w", err) } return rel.Submit(stream) } diff --git a/cmd/krel/cmd/release_notes.go b/cmd/krel/cmd/release_notes.go index 07653cabde1..ad257702e10 100644 --- a/cmd/krel/cmd/release_notes.go +++ b/cmd/krel/cmd/release_notes.go @@ -20,6 +20,7 @@ import ( "bufio" "bytes" "encoding/json" + "errors" "fmt" "os" "os/exec" @@ -29,7 +30,6 @@ import ( "time" "github.com/blang/semver" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/spf13/cobra" "gopkg.in/yaml.v2" @@ -227,7 +227,7 @@ func runReleaseNotes() (err error) { if releaseNotesOpts.tag == "" { tag, err = tryToFindLatestMinorTag() if err != nil { - return errors.Wrapf(err, "unable to find latest minor tag") + return fmt.Errorf("unable to find latest minor tag: %w", err) } releaseNotesOpts.tag = tag } else { @@ -237,7 +237,7 @@ func runReleaseNotes() (err error) { if releaseNotesOpts.userFork != "" { org, repo, err := git.ParseRepoSlug(releaseNotesOpts.userFork) if err != nil { - return errors.Wrap(err, "parsing the user's fork") + return fmt.Errorf("parsing the user's fork: %w", err) } releaseNotesOpts.githubOrg = org releaseNotesOpts.websiteRepo, releaseNotesOpts.draftRepo = repo, repo @@ -250,7 +250,7 @@ func runReleaseNotes() (err error) { // First, validate cmdline options if err := releaseNotesOpts.Validate(); err != nil { - return errors.Wrap(err, "validating command line options") + return fmt.Errorf("validating command line options: %w", err) } // before running the generators, verify that the repositories are ready @@ -260,7 +260,7 @@ func runReleaseNotes() (err error) { releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo, defaultKubernetesSigsOrg, defaultKubernetesSigsRepo, ); err != nil { - return errors.Wrapf(err, "while checking %s/%s fork", defaultKubernetesSigsOrg, defaultKubernetesSigsRepo) + return fmt.Errorf("while checking %s/%s fork: %w", defaultKubernetesSigsOrg, defaultKubernetesSigsRepo, err) } } @@ -270,7 +270,7 @@ func runReleaseNotes() (err error) { releaseNotesOpts.githubOrg, releaseNotesOpts.draftRepo, git.DefaultGithubOrg, git.DefaultGithubReleaseRepo, ); err != nil { - return errors.Wrapf(err, "while checking %s/%s fork", git.DefaultGithubOrg, git.DefaultGithubReleaseRepo) + return fmt.Errorf("while checking %s/%s fork: %w", git.DefaultGithubOrg, git.DefaultGithubReleaseRepo, err) } } @@ -278,7 +278,7 @@ func runReleaseNotes() (err error) { if releaseNotesOpts.createWebsitePR && confirmWithUser(releaseNotesOpts, "Create website pull request?") { // Run the website PR process if err := createWebsitePR(releaseNotesOpts.repoPath, tag); err != nil { - return errors.Wrap(err, "creating website PR") + return fmt.Errorf("creating website PR: %w", err) } } @@ -286,7 +286,7 @@ func runReleaseNotes() (err error) { if releaseNotesOpts.createDraftPR && confirmWithUser(releaseNotesOpts, "Create draft pull request?") { // Create the Draft PR Process if err := createDraftPR(releaseNotesOpts.repoPath, tag); err != nil { - return errors.Wrap(err, "creating Draft PR") + return fmt.Errorf("creating Draft PR: %w", err) } } @@ -301,7 +301,7 @@ func runReleaseNotes() (err error) { func createDraftPR(repoPath, tag string) (err error) { tagVersion, err := util.TagStringToSemver(tag) if err != nil { - return errors.Wrapf(err, "reading tag: %s", tag) + return fmt.Errorf("reading tag: %s: %w", tag, err) } // From v1.20.0 on we use the previous minor as a starting tag @@ -322,9 +322,9 @@ func createDraftPR(repoPath, tag string) (err error) { git.DefaultGithubOrg, git.DefaultGithubReleaseRepo, ) if err != nil { - return errors.Wrapf( - err, "while checking if repository is a fork of %s/%s", - git.DefaultGithubOrg, git.DefaultGithubReleaseRepo, + return fmt.Errorf( + "while checking if repository is a fork of %s/%s: %w", + git.DefaultGithubOrg, git.DefaultGithubReleaseRepo, err, ) } @@ -341,7 +341,7 @@ func createDraftPR(repoPath, tag string) (err error) { // Generate the notes for the current version releaseNotes, err := gatherNotesFrom(repoPath, start) if err != nil { - return errors.Wrapf(err, "while generating the release notes for tag %s", start) + return fmt.Errorf("while generating the release notes for tag %s: %w", start, err) } branchname := draftBranchPrefix + tag @@ -353,7 +353,7 @@ func createDraftPR(repoPath, tag string) (err error) { releaseNotesOpts.githubOrg, releaseNotesOpts.draftRepo, ) if err != nil { - return errors.Wrap(err, "preparing local fork of kubernetes/sig-release") + return fmt.Errorf("preparing local fork of kubernetes/sig-release: %w", err) } // The release path inside the repository @@ -362,7 +362,7 @@ func createDraftPR(repoPath, tag string) (err error) { // Check if the directory exists releaseDir := filepath.Join(sigReleaseRepo.Dir(), releasePath) if !util.Exists(releaseDir) { - return errors.Errorf("could not find release directory %s", releaseDir) + return fmt.Errorf("could not find release directory %s", releaseDir) } // If we got the --fix flag, start the fix flow @@ -373,28 +373,28 @@ func createDraftPR(repoPath, tag string) (err error) { // createNotesWorkDir is idempotent, we can use it to verify the tree is complete if err := createNotesWorkDir(releaseDir); err != nil { - return errors.Wrap(err, "creating working directory") + return fmt.Errorf("creating working directory: %w", err) } // Run the release notes fix flow err := fixReleaseNotes(filepath.Join(releaseDir, releaseNotesWorkDir), releaseNotes) if err != nil { - return errors.Wrap(err, "while running release notes fix flow") + return fmt.Errorf("while running release notes fix flow: %w", err) } // Create the map provider to read the changes so far rnMapProvider, err := notes.NewProviderFromInitString(filepath.Join(releaseDir, releaseNotesWorkDir, mapsMainDirectory)) if err != nil { - return errors.Wrap(err, "creating release notes draft") + return fmt.Errorf("creating release notes draft: %w", err) } for _, note := range releaseNotes.ByPR() { maps, err := rnMapProvider.GetMapsForPR(note.PrNumber) if err != nil { - return errors.Wrapf(err, "while getting maps for PR #%d", note.PrNumber) + return fmt.Errorf("while getting maps for PR #%d: %w", note.PrNumber, err) } for _, noteMap := range maps { if err := note.ApplyMap(noteMap, true); err != nil { - return errors.Wrapf(err, "applying note maps to PR #%d", note.PrNumber) + return fmt.Errorf("applying note maps to PR #%d: %w", note.PrNumber, err) } } } @@ -403,7 +403,7 @@ func createDraftPR(repoPath, tag string) (err error) { // Generate the results struct result, err := buildNotesResult(start, releaseNotes) if err != nil { - return errors.Wrap(err, "building release notes results") + return fmt.Errorf("building release notes results: %w", err) } // generate the notes files @@ -414,7 +414,7 @@ func createDraftPR(repoPath, tag string) (err error) { // 0600 or less err = os.WriteFile(filepath.Join(releaseDir, releaseNotesWorkDir, draftMarkdownFile), []byte(result.markdown), 0o644) if err != nil { - return errors.Wrapf(err, "writing release notes draft") + return fmt.Errorf("writing release notes draft: %w", err) } logrus.Infof("Release Notes Markdown Draft written to %s", filepath.Join(releaseDir, releaseNotesWorkDir, draftMarkdownFile)) @@ -423,7 +423,7 @@ func createDraftPR(repoPath, tag string) (err error) { // 0600 or less err = os.WriteFile(filepath.Join(releaseDir, releaseNotesWorkDir, draftJSONFile), []byte(result.json), 0o644) if err != nil { - return errors.Wrapf(err, "writing release notes json file") + return fmt.Errorf("writing release notes json file: %w", err) } logrus.Infof("Release Notes JSON version written to %s", filepath.Join(releaseDir, releaseNotesWorkDir, draftJSONFile)) @@ -431,7 +431,7 @@ func createDraftPR(repoPath, tag string) (err error) { if !autoCreatePullRequest { _, autoCreatePullRequest, err = util.Ask("Create pull request with your changes? (y/n)", "y:Y:yes|n:N:no|y", 10) if err != nil { - return errors.Wrap(err, "while asking to create pull request") + return fmt.Errorf("while asking to create pull request: %w", err) } } @@ -450,7 +450,7 @@ func createDraftPR(repoPath, tag string) (err error) { defer func() { if e := sigReleaseRepo.Cleanup(); e != nil { - err = errors.Wrap(e, "cleaning temporary sig release clone") + err = fmt.Errorf("cleaning temporary sig release clone: %w", e) } }() @@ -458,13 +458,13 @@ func createDraftPR(repoPath, tag string) (err error) { if err := createDraftCommit( sigReleaseRepo, releasePath, "Release Notes draft for k/k "+tag, ); err != nil { - return errors.Wrap(err, "creating release notes commit") + return fmt.Errorf("creating release notes commit: %w", err) } // push to the user's remote logrus.Infof("Pushing modified release notes draft to %s/%s", releaseNotesOpts.githubOrg, releaseNotesOpts.draftRepo) if err := sigReleaseRepo.PushToRemote(userForkName, branchname); err != nil { - return errors.Wrapf(err, "pushing %s to remote", userForkName) + return fmt.Errorf("pushing %s to remote: %w", userForkName, err) } // Create a PR against k/sig-release using the github API @@ -493,7 +493,7 @@ func createDraftPR(repoPath, tag string) (err error) { if err != nil { logrus.Warnf("An error has occurred while creating the pull request for %s", tag) logrus.Warn("While the PR failed, the release notes draft was generated and submitted to your fork") - return errors.Wrap(err, "creating the pull request") + return fmt.Errorf("creating the pull request: %w", err) } logrus.Infof( "Successfully created PR: %s%s/%s/pull/%d", @@ -511,12 +511,12 @@ func createDraftPR(repoPath, tag string) (err error) { func createDraftCommit(repo *git.Repo, releasePath, commitMessage string) error { // add the updated draft if err := repo.Add(filepath.Join(releasePath, releaseNotesWorkDir, draftMarkdownFile)); err != nil { - return errors.Wrap(err, "adding release notes draft to staging area") + return fmt.Errorf("adding release notes draft to staging area: %w", err) } // add the json draft if err := repo.Add(filepath.Join(releasePath, releaseNotesWorkDir, draftJSONFile)); err != nil { - return errors.Wrap(err, "adding release notes json to staging area") + return fmt.Errorf("adding release notes json to staging area: %w", err) } // List of directories we'll consider for the PR @@ -547,11 +547,11 @@ func createDraftCommit(repo *git.Repo, releasePath, commitMessage string) error matches, err := filepath.Glob(filepath.Join(repo.Dir(), dirData.Path, "*"+dirData.Ext)) logrus.Debugf("Adding %d %s from %s to commit", len(matches), dirData.Name, dirData.Path) if err != nil { - return errors.Wrapf(err, "checking for %s files in %s", dirData.Ext, dirData.Path) + return fmt.Errorf("checking for %s files in %s: %w", dirData.Ext, dirData.Path, err) } if len(matches) > 0 { if err := repo.Add(filepath.Join(dirData.Path, "*"+dirData.Ext)); err != nil { - return errors.Wrapf(err, "adding %s to staging area", dirData.Name) + return fmt.Errorf("adding %s to staging area: %w", dirData.Name, err) } } } else { @@ -561,7 +561,7 @@ func createDraftCommit(repo *git.Repo, releasePath, commitMessage string) error // add the generated draft if err := repo.UserCommit(commitMessage); err != nil { - return errors.Wrapf(err, "creating commit in %s/%s", releaseNotesOpts.githubOrg, releaseNotesOpts.draftRepo) + return fmt.Errorf("creating commit in %s/%s: %w", releaseNotesOpts.githubOrg, releaseNotesOpts.draftRepo, err) } return nil } @@ -573,7 +573,7 @@ func addReferenceToAssetsFile(repoPath, newJSONFile string) error { file, err := os.Open(assetsFullPath) if err != nil { - return errors.Wrap(err, "opening assets.ts to check for current version") + return fmt.Errorf("opening assets.ts to check for current version: %w", err) } defer file.Close() @@ -612,7 +612,7 @@ func addReferenceToAssetsFile(repoPath, newJSONFile string) error { // write the modified assets.ts file if err := os.WriteFile(assetsFullPath, assetsBuffer.Bytes(), os.FileMode(0o644)); err != nil { - return errors.Wrap(err, "writing assets.ts file") + return fmt.Errorf("writing assets.ts file: %w", err) } return nil @@ -622,19 +622,19 @@ func addReferenceToAssetsFile(repoPath, newJSONFile string) error { func processJSONOutput(repoPath string) error { npmpath, err := exec.LookPath("npm") if err != nil { - return errors.Wrap(err, "while looking for npm in your path") + return fmt.Errorf("while looking for npm in your path: %w", err) } // run npm install logrus.Info("Installing npm modules, this can take a while") if err := command.NewWithWorkDir(repoPath, npmpath, "install").RunSuccess(); err != nil { - return errors.Wrap(err, "running npm install in kubernetes-sigs/release-notes") + return fmt.Errorf("running npm install in kubernetes-sigs/release-notes: %w", err) } // run npm prettier logrus.Info("Running npm prettier...") if err := command.NewWithWorkDir(repoPath, npmpath, "run", "prettier").RunSuccess(); err != nil { - return errors.Wrap(err, "running npm prettier in kubernetes-sigs/release-notes") + return fmt.Errorf("running npm prettier in kubernetes-sigs/release-notes: %w", err) } return nil @@ -644,13 +644,13 @@ func processJSONOutput(repoPath string) error { func createWebsitePR(repoPath, tag string) (err error) { _, err = util.TagStringToSemver(tag) if err != nil { - return errors.Wrapf(err, "reading tag: %s", tag) + return fmt.Errorf("reading tag: %s: %w", tag, err) } // Generate the release notes for ust the current tag jsonStr, err := releaseNotesJSON(repoPath, tag) if err != nil { - return errors.Wrapf(err, "generating release notes in JSON format") + return fmt.Errorf("generating release notes in JSON format: %w", err) } jsonNotesFilename := fmt.Sprintf("release-notes-%s.json", tag[1:]) @@ -662,17 +662,17 @@ func createWebsitePR(repoPath, tag string) (err error) { defaultKubernetesSigsRepo, releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo, ) if err != nil { - return errors.Wrap(err, "preparing local fork branch") + return fmt.Errorf("preparing local fork branch: %w", err) } defer func() { if e := k8sSigsRepo.Cleanup(); e != nil { - err = errors.Wrap(e, "cleaning up k/sigs repo") + err = fmt.Errorf("cleaning up k/sigs repo: %w", e) } }() // add a reference to the new json file in assets.ts if err := addReferenceToAssetsFile(k8sSigsRepo.Dir(), jsonNotesFilename); err != nil { - return errors.Wrapf(err, "adding %s to assets file", jsonNotesFilename) + return fmt.Errorf("adding %s to assets file: %w", jsonNotesFilename, err) } // generate the notes @@ -681,31 +681,31 @@ func createWebsitePR(repoPath, tag string) (err error) { if err := os.WriteFile( filepath.Join(k8sSigsRepo.Dir(), jsonNotesPath), []byte(jsonStr), os.FileMode(0o644), ); err != nil { - return errors.Wrapf(err, "writing release notes json file") + return fmt.Errorf("writing release notes json file: %w", err) } // Run NPM prettier if err := processJSONOutput(k8sSigsRepo.Dir()); err != nil { - return errors.Wrap(err, "while formatting release notes JSON files") + return fmt.Errorf("while formatting release notes JSON files: %w", err) } // add the modified files & commit the results if err := k8sSigsRepo.Add(jsonNotesPath); err != nil { - return errors.Wrap(err, "adding release notes draft to staging area") + return fmt.Errorf("adding release notes draft to staging area: %w", err) } if err := k8sSigsRepo.Add(filepath.FromSlash(assetsFilePath)); err != nil { - return errors.Wrap(err, "adding release notes draft to staging area") + return fmt.Errorf("adding release notes draft to staging area: %w", err) } if err := k8sSigsRepo.UserCommit(fmt.Sprintf("Patch relnotes.k8s.io with release %s", tag)); err != nil { - return errors.Wrapf(err, "Error creating commit in %s/%s", releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo) + return fmt.Errorf("error creating commit in %s/%s: %w", releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo, err) } // push to the user's fork logrus.Infof("Pushing website changes to %s/%s", releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo) if err := k8sSigsRepo.PushToRemote(userForkName, branchname); err != nil { - return errors.Wrapf(err, "pushing %s to %s/%s", userForkName, releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo) + return fmt.Errorf("pushing %s to %s/%s: %w", userForkName, releaseNotesOpts.githubOrg, releaseNotesOpts.websiteRepo, err) } // Create a PR against k-sigs/release-notes using the github API @@ -726,7 +726,7 @@ func createWebsitePR(repoPath, tag string) (err error) { if err != nil { logrus.Warnf("An error has occurred while creating the pull request for %s", tag) logrus.Warn("While the PR failed, the release notes where generated and submitted to your fork") - return errors.Wrap(err, "creating the pull request") + return fmt.Errorf("creating the pull request: %w", err) } logrus.Infof( @@ -762,7 +762,7 @@ func releaseNotesJSON(repoPath, tag string) (jsonString string, err error) { tagVersion, err := util.TagStringToSemver(tag) if err != nil { - return "", errors.Wrap(err, "parsing semver from tag string") + return "", fmt.Errorf("parsing semver from tag string: %w", err) } logrus.Info("Cloning kubernetes/sig-release to read mapping files") @@ -770,7 +770,7 @@ func releaseNotesJSON(repoPath, tag string) (jsonString string, err error) { git.DefaultGithubOrg, git.DefaultGithubReleaseRepo, false, ) if err != nil { - return "", errors.Wrap(err, "performing clone of k/sig-release") + return "", fmt.Errorf("performing clone of k/sig-release: %w", err) } defer func() { if e := sigReleaseRepo.Cleanup(); e != nil { @@ -783,14 +783,14 @@ func releaseNotesJSON(repoPath, tag string) (jsonString string, err error) { // Ensure we have a valid branch if !git.IsReleaseBranch(branchName) { - return "", errors.New("Could not determine a release branch for tag") + return "", errors.New("could not determine a release branch for tag") } // Preclone the repo to be able to read branches and tags logrus.Infof("Cloning %s/%s", git.DefaultGithubOrg, git.DefaultGithubRepo) repo, err := git.CloneOrOpenGitHubRepo(repoPath, git.DefaultGithubOrg, git.DefaultGithubRepo, false) if err != nil { - return "", errors.Wrap(err, "cloning default github repo") + return "", fmt.Errorf("cloning default github repo: %w", err) } // Chech if release branch already exists @@ -827,7 +827,7 @@ func releaseNotesJSON(repoPath, tag string) (jsonString string, err error) { // All others from the previous existing tag startTag, err = repo.PreviousTag(tag, branchName) if err != nil { - return "", errors.Wrap(err, "getting previous tag from branch") + return "", fmt.Errorf("getting previous tag from branch: %w", err) } tagChoice = "previous tag" } @@ -863,14 +863,14 @@ func releaseNotesJSON(repoPath, tag string) (jsonString string, err error) { // Fetch the notes releaseNotes, err := notes.GatherReleaseNotes(notesOptions) if err != nil { - return "", errors.Wrapf(err, "gathering release notes") + return "", fmt.Errorf("gathering release notes: %w", err) } doc, err := document.New( releaseNotes, notesOptions.StartRev, notesOptions.EndRev, ) if err != nil { - return "", errors.Wrapf(err, "creating release note document") + return "", fmt.Errorf("creating release note document: %w", err) } doc.PreviousRevision = startTag doc.CurrentRevision = tag @@ -878,7 +878,7 @@ func releaseNotesJSON(repoPath, tag string) (jsonString string, err error) { // Create the JSON j, err := json.Marshal(releaseNotes.ByPR()) if err != nil { - return "", errors.Wrapf(err, "generating release notes JSON") + return "", fmt.Errorf("generating release notes JSON: %w", err) } return string(j), err @@ -908,7 +908,7 @@ func gatherNotesFrom(repoPath, startTag string) (*notes.ReleaseNotes, error) { // Fetch the notes releaseNotes, err := notes.GatherReleaseNotes(notesOptions) if err != nil { - return nil, errors.Wrapf(err, "gathering release notes") + return nil, fmt.Errorf("gathering release notes: %w", err) } return releaseNotes, nil @@ -919,7 +919,7 @@ func buildNotesResult(startTag string, releaseNotes *notes.ReleaseNotes) (*relea releaseNotes, startTag, releaseNotesOpts.tag, ) if err != nil { - return nil, errors.Wrapf(err, "creating release note document") + return nil, fmt.Errorf("creating release note document: %w", err) } doc.PreviousRevision = startTag doc.CurrentRevision = releaseNotesOpts.tag @@ -929,15 +929,15 @@ func buildNotesResult(startTag string, releaseNotes *notes.ReleaseNotes) (*relea "", "", "", options.GoTemplateDefault, ) if err != nil { - return nil, errors.Wrapf( - err, "rendering release notes to markdown", + return nil, fmt.Errorf( + "rendering release notes to markdown: %w", err, ) } // Create the JSON j, err := json.MarshalIndent(releaseNotes.ByPR(), "", " ") if err != nil { - return nil, errors.Wrapf(err, "generating release notes JSON") + return nil, fmt.Errorf("generating release notes JSON: %w", err) } return &releaseNotesResult{markdown: markdown, json: string(j)}, nil @@ -948,13 +948,13 @@ func (o *releaseNotesOptions) Validate() error { // Check that we have a GitHub token set token, isset := os.LookupEnv(github.TokenEnvKey) if !isset || token == "" { - return errors.New("Cannot generate release notes if GitHub token is not set") + return errors.New("cannot generate release notes if GitHub token is not set") } // If a tag is defined, see if it is a valid semver tag _, err := util.TagStringToSemver(releaseNotesOpts.tag) if err != nil { - return errors.Wrapf(err, "reading tag: %s", releaseNotesOpts.tag) + return fmt.Errorf("reading tag: %s: %w", releaseNotesOpts.tag, err) } // Options for PR creation @@ -978,13 +978,13 @@ func (sd *sessionData) Save() error { jsonData, err := json.MarshalIndent(sd, "", " ") if err != nil { - return errors.Wrap(err, "marshaling session data") + return fmt.Errorf("marshaling session data: %w", err) } if err := os.WriteFile( filepath.Join(sd.Path, fmt.Sprintf("maps-%d.json", sd.Date)), jsonData, os.FileMode(0o644)); err != nil { - return errors.Wrap(err, "writing session data to disk") + return fmt.Errorf("writing session data to disk: %w", err) } return nil } @@ -993,7 +993,7 @@ func (sd *sessionData) Save() error { func readFixSessions(sessionPath string) (pullRequestChecklist map[int]string, err error) { files, err := os.ReadDir(sessionPath) if err != nil { - return nil, errors.Wrap(err, "reading working directory") + return nil, fmt.Errorf("reading working directory: %w", err) } pullRequestList := make([]struct { Number int `json:"nr"` @@ -1007,10 +1007,10 @@ func readFixSessions(sessionPath string) (pullRequestChecklist map[int]string, e logrus.Debugf("Reading session data from %s", fileData.Name()) jsonData, err := os.ReadFile(filepath.Join(sessionPath, fileData.Name())) if err != nil { - return nil, errors.Wrapf(err, "reading session data from %s", fileData.Name()) + return nil, fmt.Errorf("reading session data from %s: %w", fileData.Name(), err) } if err := json.Unmarshal(jsonData, currentSession); err != nil { - return nil, errors.Wrapf(err, "unmarshalling session data in %s", fileData.Name()) + return nil, fmt.Errorf("unmarshalling session data in %s: %w", fileData.Name(), err) } pullRequestList = append(pullRequestList, currentSession.PullRequests...) } @@ -1030,11 +1030,11 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { // Get data to record the session userEmail, err := git.GetUserEmail() if err != nil { - return errors.Wrap(err, "getting local user's email") + return fmt.Errorf("getting local user's email: %w", err) } userName, err := git.GetUserName() if err != nil { - return errors.Wrap(err, "getting local user's name") + return fmt.Errorf("getting local user's name: %w", err) } // Check the workDir before going further @@ -1053,7 +1053,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { // Read the list of all PRs we've processed so far pullRequestChecklist, err := readFixSessions(filepath.Join(workDir, mapsSessionDirectory)) if err != nil { - return errors.Wrapf(err, "reading previous session data") + return fmt.Errorf("reading previous session data: %w", err) } // Greet the user with basic instructions @@ -1078,13 +1078,13 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { _, _, err = util.Ask("Press enter to start editing", "y:Y:yes|n:N:no|y", 10) } if err != nil { - return errors.Wrap(err, "asking to retrieve last session") + return fmt.Errorf("asking to retrieve last session: %w", err) } // Bring up the provider provider, err := notes.NewProviderFromInitString(workDir) if err != nil { - return errors.Wrap(err, "while getting map provider for current notes") + return fmt.Errorf("while getting map provider for current notes: %w", err) } const ( @@ -1096,7 +1096,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { contentHash, err := note.ContentHash() noteReviewed := false if err != nil { - return errors.Wrapf(err, "getting the content hash for PR#%d", pr) + return fmt.Errorf("getting the content hash for PR#%d: %w", pr, err) } // We'll skip editing if the Releas Note has been reviewed if _, ok := pullRequestChecklist[pr]; ok && @@ -1113,7 +1113,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { fmt.Printf("Pull Request URL: %skubernetes/kubernetes/pull/%d%s", github.GitHubURL, pr, nl) noteMaps, err := provider.GetMapsForPR(pr) if err != nil { - return errors.Wrapf(err, "while getting map for PR #%d", pr) + return fmt.Errorf("while getting map for PR #%d: %w", pr, err) } // Capture the original note values to compare @@ -1133,7 +1133,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { fmt.Println("✨ Note contents was previously modified with a map") for _, noteMap := range noteMaps { if err := note.ApplyMap(noteMap, true); err != nil { - return errors.Wrapf(err, "applying notemap for PR #%d", pr) + return fmt.Errorf("applying notemap for PR #%d: %w", pr, err) } } } @@ -1159,7 +1159,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { logrus.Info("Input cancelled, exiting edit flow") return nil } - return errors.Wrap(err, "while asking to edit release note") + return fmt.Errorf("while asking to edit release note: %w", err) } noteReviewed = true @@ -1177,7 +1177,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { "y:yes|n:no", 10, ) if err != nil { - return errors.Wrap(err, "while asking to re-edit release note") + return fmt.Errorf("while asking to re-edit release note: %w", err) } // If user chooses not to fix the faulty yaml, do not mark as fixed if !retryEditingChoice { @@ -1185,7 +1185,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { break } } else { - return errors.Wrap(err, "while editing release note") + return fmt.Errorf("while editing release note: %w", err) } } } @@ -1200,7 +1200,7 @@ func fixReleaseNotes(workDir string, releaseNotes *notes.ReleaseNotes) error { Hash: contentHash, }) if err := session.Save(); err != nil { - return errors.Wrap(err, "while saving editing session data") + return fmt.Errorf("while saving editing session data: %w", err) } } } @@ -1315,7 +1315,7 @@ func editReleaseNote(pr int, workDir string, originalNote, modifiedNote *notes.R // map with the original values yamlCode, err := yaml.Marshal(&unalteredFields) if err != nil { - return false, errors.Wrap(err, "marshalling release note to map") + return false, fmt.Errorf("marshalling release note to map: %w", err) } output += "# " + strings.ReplaceAll(string(yamlCode), "\n", "\n# ") } else { @@ -1323,12 +1323,12 @@ func editReleaseNote(pr int, workDir string, originalNote, modifiedNote *notes.R // values commented out for reference yamlCode, err := yaml.Marshal(&modifiedFields) if err != nil { - return false, errors.Wrap(err, "marshalling release note to map") + return false, fmt.Errorf("marshalling release note to map: %w", err) } unalteredYAML, err := yaml.Marshal(&unalteredFields.ReleaseNote) if err != nil { - return false, errors.Wrap(err, "marshalling release note to map") + return false, fmt.Errorf("marshalling release note to map: %w", err) } output += string(yamlCode) + " # " + strings.ReplaceAll(string(unalteredYAML), "\n", "\n # ") } @@ -1336,7 +1336,7 @@ func editReleaseNote(pr int, workDir string, originalNote, modifiedNote *notes.R kubeEditor := editor.NewDefaultEditor([]string{"KUBE_EDITOR", "EDITOR"}) changes, tempFilePath, err := kubeEditor.LaunchTempFile("release-notes-map-", ".yaml", bytes.NewReader([]byte(output))) if err != nil { - return false, errors.Wrap(err, "while launching editor") + return false, fmt.Errorf("while launching editor: %w", err) } defer func() { @@ -1375,18 +1375,18 @@ func editReleaseNote(pr int, workDir string, originalNote, modifiedNote *notes.R if err != nil { logrus.Error("The YAML code has errors") - return true, errors.Wrap(err, "while verifying if changes are a valid map") + return true, fmt.Errorf("while verifying if changes are a valid map: %w", err) } if testMap.PR == 0 { logrus.Error("The yaml code does not have a PR number") - return true, errors.New("Invalid map: the YAML code did not have a PR number") + return true, errors.New("invalid map: the YAML code did not have a PR number") } // Remarshall the newyaml to save only the new values newYAML, err := yaml.Marshal(testMap) if err != nil { - return true, errors.Wrap(err, "while re-marshaling new map") + return true, fmt.Errorf("while re-marshaling new map: %w", err) } // Write the new map, removing the instructions @@ -1394,7 +1394,7 @@ func editReleaseNote(pr int, workDir string, originalNote, modifiedNote *notes.R err = os.WriteFile(mapPath, newYAML, os.FileMode(0o644)) if err != nil { logrus.Errorf("Error writing map to %s: %s", mapPath, err) - return true, errors.Wrap(err, "writing modified release note map") + return true, fmt.Errorf("writing modified release note map: %w", err) } return false, nil @@ -1412,7 +1412,7 @@ func createNotesWorkDir(releaseDir string) error { } { if !util.Exists(dirPath) { if err := os.Mkdir(dirPath, os.FileMode(0o755)); err != nil { - return errors.Wrap(err, "creating working directory") + return fmt.Errorf("creating working directory: %w", err) } } } diff --git a/cmd/krel/cmd/testgrid.go b/cmd/krel/cmd/testgrid.go index af7d5cffc77..130bb3e1cf4 100644 --- a/cmd/krel/cmd/testgrid.go +++ b/cmd/krel/cmd/testgrid.go @@ -19,6 +19,7 @@ package cmd import ( "context" "encoding/json" + "errors" "fmt" "net/url" "os" @@ -28,7 +29,6 @@ import ( "github.com/google/uuid" "github.com/mitchellh/mapstructure" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/spf13/cobra" @@ -118,7 +118,7 @@ func runTestGridShot(opts *TestGridOptions) error { logrus.Info("Starting krel testgrishot...") if err := opts.Validate(); err != nil { - return errors.Wrap(err, "validating testgridshot options") + return fmt.Errorf("validating testgridshot options: %w", err) } testgridJobs := []TestGridJob{} @@ -126,15 +126,13 @@ func runTestGridShot(opts *TestGridOptions) error { testGridDashboard := fmt.Sprintf("%s/sig-release-%s-%s/summary", opts.testgridURL, opts.branch, board) content, err := http.NewAgent().WithTimeout(30 * time.Second).Get(testGridDashboard) if err != nil { - return errors.Wrapf(err, - "unable to retrieve release announcement form url: %s", testGridDashboard, - ) + return fmt.Errorf("unable to retrieve release announcement form url: %s: %w", testGridDashboard, err) } var result map[string]interface{} err = json.Unmarshal(content, &result) if err != nil { - return errors.Wrap(err, "unable unmarshal the testgrid response") + return fmt.Errorf("unable unmarshal the testgrid response: %w", err) } testgridJobsTemp := []TestGridJob{} @@ -142,7 +140,7 @@ func runTestGridShot(opts *TestGridOptions) error { result := TestgridJobInfo{} err = mapstructure.Decode(jobData, &result) if err != nil { - return errors.Wrap(err, "decode testgrid data") + return fmt.Errorf("decode testgrid data: %w", err) } for _, state := range opts.states { @@ -160,13 +158,13 @@ func runTestGridShot(opts *TestGridOptions) error { dateNow := fmt.Sprintf("%s-%s", time.Now().UTC().Format(layoutISO), uuid.NewString()) testgridJobs, err = processDashboards(testgridJobs, dateNow, opts) if err != nil { - return errors.Wrap(err, "processing the dashboards") + return fmt.Errorf("processing the dashboards: %w", err) } } err := generateIssueComment(testgridJobs, opts) if err != nil { - return errors.Wrap(err, "generating the GitHub issue comment") + return fmt.Errorf("generating the GitHub issue comment: %w", err) } return nil @@ -180,19 +178,19 @@ func processDashboards(testgridJobs []TestGridJob, date string, opts *TestGridOp content, err := http.NewAgent().WithTimeout(300 * time.Second).Get(rendertronURL) if err != nil { - return testgridJobs, errors.Wrapf(err, "failed to get the testgrid screenshot") + return testgridJobs, fmt.Errorf("failed to get the testgrid screenshot: %w", err) } jobFile := fmt.Sprintf("/tmp/%s-%s-%s.jpg", job.DashboardName, strings.ReplaceAll(job.JobName, " ", "_"), job.Status) f, err := os.Create(jobFile) if err != nil { - return testgridJobs, errors.Wrapf(err, "failed to create the file %s", jobFile) + return testgridJobs, fmt.Errorf("failed to create the file %s: %w", jobFile, err) } _, err = f.Write(content) f.Close() if err != nil { - return testgridJobs, errors.Wrapf(err, "failed to write the content to the file %s", jobFile) + return testgridJobs, fmt.Errorf("failed to write the content to the file %s: %w", jobFile, err) } logrus.Infof("Screenshot saved for %s: %s", job.JobName, jobFile) @@ -200,10 +198,10 @@ func processDashboards(testgridJobs []TestGridJob, date string, opts *TestGridOp gcs := object.NewGCS() if err := gcs.CopyToRemote(jobFile, gcsPath); err != nil { - return testgridJobs, errors.Wrapf(err, "failed to upload the file %s to GCS bucket %s", jobFile, gcsPath) + return testgridJobs, fmt.Errorf("failed to upload the file %s to GCS bucket %s: %w", jobFile, gcsPath, err) } if err := os.Remove(jobFile); err != nil { - return testgridJobs, errors.Wrapf(err, "remove jobfile") + return testgridJobs, fmt.Errorf("remove jobfile: %w", err) } testgridJobs[i].GCSLocation = fmt.Sprintf("https://storage.googleapis.com/%s", gcsPath) logrus.Infof("Screenshot will be available for job %s at %s", job.JobName, testgridJobs[i].GCSLocation) @@ -254,7 +252,7 @@ func generateIssueComment(testgridJobs []TestGridJob, opts *TestGridOptions) err _, _, err := gh.Client().CreateComment(context.Background(), git.DefaultGithubOrg, k8sSigReleaseRepo, opts.gitHubIssue, strings.Join(output, "\n")) if err != nil { - return errors.Wrap(err, "creating the GitHub comment") + return fmt.Errorf("creating the GitHub comment: %w", err) } logrus.Infof("Comment created in the GitHub Issue https://github.com/%s/%s/issues/%d. Thanks for using krel!", git.DefaultGithubOrg, k8sSigReleaseRepo, opts.gitHubIssue) } else { @@ -303,17 +301,17 @@ func (o *TestGridOptions) Validate() error { issue, _, err := gh.Client().GetIssue(context.Background(), git.DefaultGithubOrg, k8sSigReleaseRepo, o.gitHubIssue) if err != nil || issue == nil { - return errors.Wrapf(err, "getting the GitHub Issue %d", o.gitHubIssue) + return fmt.Errorf("getting the GitHub Issue %d: %w", o.gitHubIssue, err) } // The issue needs to be in open state if issue.GetState() != "open" { - return errors.Errorf("GitHub Issue %d is %s needs to be a open issue", o.gitHubIssue, issue.GetState()) + return fmt.Errorf("GitHub Issue %d is %s needs to be a open issue", o.gitHubIssue, issue.GetState()) } // Should be a Issue and not a Pull Request if issue.PullRequestLinks != nil { - return errors.New("This is a Pull Request and not a GitHub Issue") + return errors.New("this is a Pull Request and not a GitHub Issue") } } From 7e1c2b87ab7e56cf8224f42ae4eb2f32b3d56505 Mon Sep 17 00:00:00 2001 From: Debanitrkl <118bm0622@nitrkl.ac.in> Date: Wed, 15 Jun 2022 22:26:32 +0530 Subject: [PATCH 2/6] small nits --- cmd/krel/cmd/announce_build.go | 1 - 1 file changed, 1 deletion(-) diff --git a/cmd/krel/cmd/announce_build.go b/cmd/krel/cmd/announce_build.go index 96145941007..ba019a3df9d 100644 --- a/cmd/krel/cmd/announce_build.go +++ b/cmd/krel/cmd/announce_build.go @@ -25,7 +25,6 @@ import ( "strings" "text/template" - "github.com/pkg/errors" "github.com/sirupsen/logrus" "github.com/spf13/cobra" From 0c378084d0c62057e8f6fe86255c3f51f2898e99 Mon Sep 17 00:00:00 2001 From: Debanitrkl <118bm0622@nitrkl.ac.in> Date: Wed, 15 Jun 2022 22:37:15 +0530 Subject: [PATCH 3/6] small nits --- cmd/krel/cmd/announce_build.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/krel/cmd/announce_build.go b/cmd/krel/cmd/announce_build.go index ba019a3df9d..4469ac8dda0 100644 --- a/cmd/krel/cmd/announce_build.go +++ b/cmd/krel/cmd/announce_build.go @@ -250,7 +250,7 @@ func (opts *buildAnnounceOptions) saveAnnouncement(announcementSubject string, a return nil } -func getGoVersion() (string, error) { +func (getGoVersion) (string, error) { cmdStatus, err := command.New( "go", "version"). RunSilentSuccessOutput() From 2958f78982953832baed2d63631e3b4d8f40bc43 Mon Sep 17 00:00:00 2001 From: Debanitrkl <118bm0622@nitrkl.ac.in> Date: Wed, 15 Jun 2022 22:51:05 +0530 Subject: [PATCH 4/6] reverted the previous changes due to syntax error --- cmd/krel/cmd/announce_build.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cmd/krel/cmd/announce_build.go b/cmd/krel/cmd/announce_build.go index 4469ac8dda0..2d72b79c49b 100644 --- a/cmd/krel/cmd/announce_build.go +++ b/cmd/krel/cmd/announce_build.go @@ -250,14 +250,13 @@ func (opts *buildAnnounceOptions) saveAnnouncement(announcementSubject string, a return nil } -func (getGoVersion) (string, error) { +func getGoVersion (string, error) { cmdStatus, err := command.New( "go", "version"). RunSilentSuccessOutput() if err != nil { return "", fmt.Errorf("get go version: %w", err) } - versionRegex := regexp.MustCompile(semVerRegex) return versionRegex.FindString(strings.TrimSpace(cmdStatus.Output())), nil } From c044b78ab5395afa1999c1191e4c89a8158824be Mon Sep 17 00:00:00 2001 From: Debanitrkl <118bm0622@nitrkl.ac.in> Date: Thu, 16 Jun 2022 18:33:47 +0530 Subject: [PATCH 5/6] fixed typo --- cmd/krel/cmd/announce_build.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/krel/cmd/announce_build.go b/cmd/krel/cmd/announce_build.go index 2d72b79c49b..fca08464219 100644 --- a/cmd/krel/cmd/announce_build.go +++ b/cmd/krel/cmd/announce_build.go @@ -250,11 +250,11 @@ func (opts *buildAnnounceOptions) saveAnnouncement(announcementSubject string, a return nil } -func getGoVersion (string, error) { +func getGoVersion() (string, error) { cmdStatus, err := command.New( "go", "version"). RunSilentSuccessOutput() - if err != nil { + if err != nil { return "", fmt.Errorf("get go version: %w", err) } versionRegex := regexp.MustCompile(semVerRegex) From e0dd7245eb7c9ccbb8924ed0aee4e9d3f5d7a80d Mon Sep 17 00:00:00 2001 From: Debanitrkl <118bm0622@nitrkl.ac.in> Date: Tue, 21 Jun 2022 11:55:12 +0530 Subject: [PATCH 6/6] added missed parentheses --- cmd/krel/cmd/announce_build.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/krel/cmd/announce_build.go b/cmd/krel/cmd/announce_build.go index fca08464219..bf952964ed6 100644 --- a/cmd/krel/cmd/announce_build.go +++ b/cmd/krel/cmd/announce_build.go @@ -245,7 +245,7 @@ func (opts *buildAnnounceOptions) saveAnnouncement(announcementSubject string, a err = os.WriteFile(absOutputPath, []byte(announcementSubject), os.FileMode(0o644)) if err != nil { return fmt.Errorf("saving announcement-subject.txt: %w", err) - + } logrus.Info("Kubernetes Announcement created.") return nil } @@ -254,7 +254,7 @@ func getGoVersion() (string, error) { cmdStatus, err := command.New( "go", "version"). RunSilentSuccessOutput() - if err != nil { + if err != nil { return "", fmt.Errorf("get go version: %w", err) } versionRegex := regexp.MustCompile(semVerRegex)