Randomly check for krew updates

cmd/krew/cmd/internal/fetch_tag.go

@@ -0,0 +1,50 @@
+// Copyright 2020 The Kubernetes Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/pkg/errors"
+	"k8s.io/klog"
+)
+
+const (
+	githubVersionURL = "https://api.github.com/repos/kubernetes-sigs/krew/releases/latest"
+)
+
+// for testing
+var versionURL = githubVersionURL
+
+// FetchLatestTag fetches the tag name of the latest release from GitHub.
+func FetchLatestTag() (string, error) {
+	klog.V(4).Infof("Fetching latest tag from GitHub")
+	response, err := http.Get(versionURL)
+	if err != nil {
+		return "", errors.Wrapf(err, "could not GET the latest release")
+	}
+	defer response.Body.Close()
+
+	var res struct {
+		Tag string `json:"tag_name"`
+	}
+	klog.V(4).Infof("Parsing response from GitHub")
+	if err := json.NewDecoder(response.Body).Decode(&res); err != nil {
+		return "", errors.Wrapf(err, "could not parse the response from GitHub")
+	}
+	klog.V(4).Infof("Fetched latest tag name (%s) from GitHub", res.Tag)
+	return res.Tag, nil
+}

cmd/krew/cmd/internal/fetch_tag_test.go

@@ -0,0 +1,91 @@
+// Copyright 2020 The Kubernetes Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package internal
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func Test_fetchLatestTag_GitHubAPI(t *testing.T) {
+	tag, err := FetchLatestTag()
+	if err != nil {
+		t.Error(err)
+	}
+	if tag == "" {
+		t.Errorf("Expected a latest tag in the response")
+	}
+}
+
+func Test_fetchLatestTag(t *testing.T) {
+	tests := []struct {
+		name      string
+		expected  string
+		response  string
+		shouldErr bool
+	}{
+		{
+			name:      "broken json",
+			response:  `{"tag_name"::]`,
+			shouldErr: true,
+		},
+		{
+			name:     "field missing",
+			response: `{}`,
+		},
+		{
+			name:     "should get the correct tag",
+			response: `{"tag_name": "some_tag"}`,
+			expected: "some_tag",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(tt *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(
+				func(w http.ResponseWriter, _ *http.Request) {
+					_, _ = w.Write([]byte(test.response))
+				},
+			))
+
+			defer server.Close()
+
+			versionURL = server.URL
+			defer func() { versionURL = githubVersionURL }()
+
+			tag, err := FetchLatestTag()
+			if test.shouldErr && err == nil {
+				tt.Error("Expected an error but found none")
+			}
+			if !test.shouldErr && err != nil {
+				tt.Errorf("Expected no error but found: %s", err)
+			}
+			if tag != test.expected {
+				tt.Errorf("Expected %s, got %s", test.expected, tag)
+			}
+		})
+	}
+}
+
+func Test_fetchLatestTagFailure(t *testing.T) {
+	versionURL = "http://localhost/nirvana"
+	defer func() { versionURL = githubVersionURL }()
+
+	_, err := FetchLatestTag()
+	if err == nil {
+		t.Error("Expected an error but found none")
+	}
+}

cmd/krew/cmd/root.go

@@ -17,7 +17,9 @@ package cmd
 import (
 	"flag"
 	"fmt"
+	"math/rand"
 	"os"
+	"time"
 
 	"github.com/fatih/color"
 	"github.com/mattn/go-isatty"
@@ -31,12 +33,26 @@ import (
 	"sigs.k8s.io/krew/internal/gitutil"
 	"sigs.k8s.io/krew/internal/installation"
 	"sigs.k8s.io/krew/internal/installation/receipt"
+	"sigs.k8s.io/krew/internal/installation/semver"
 	"sigs.k8s.io/krew/internal/receiptsmigration"
+	"sigs.k8s.io/krew/internal/version"
 	"sigs.k8s.io/krew/pkg/constants"
 )
 
+const (
+	upgradeNotification = "A newer version of krew is available (%s -> %s).\nRun \"kubectl krew upgrade\" to get the newest version!\n"
+
+	// showRate is the percentage of krew runs for which the upgrade check is performed.
+	showRate = 0.4
+)
+
 var (
 	paths environment.Paths // krew paths used by the process
+
+	// latestTag is updated by a go-routine with the latest tag from GitHub.
+	// An empty string indicates that the API request was skipped or
+	// has not completed.
+	latestTag = ""
 )
 
 // rootCmd represents the base command when called without any subcommands
@@ -48,6 +64,7 @@ You can invoke krew through kubectl: "kubectl krew [command]..."`,
 	SilenceUsage:      true,
 	SilenceErrors:     true,
 	PersistentPreRunE: preRun,
+	PersistentPostRun: showUpgradeNotification,
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -64,6 +81,7 @@ func Execute() {
 
 func init() {
 	klog.InitFlags(nil)
+	rand.Seed(time.Now().UnixNano())
 
 	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
 	_ = flag.CommandLine.Parse([]string{}) // convince pkg/flag we parsed the flags
@@ -95,6 +113,19 @@ func preRun(cmd *cobra.Command, _ []string) error {
 		klog.Fatal(err)
 	}
 
+	go func() {
+		if _, disabled := os.LookupEnv("KREW_NO_UPGRADE_CHECK"); disabled ||
+			isDevelopmentBuild() || // no upgrade check for dev builds
+			showRate < rand.Float64() { // only do the upgrade check randomly
+			return
+		}
+		var err error
+		latestTag, err = internal.FetchLatestTag()
+		if err != nil {
+			klog.V(1).Infoln("WARNING:", err)
+		}
+	}()
+
 	// detect if receipts migration (v0.2.x->v0.3.x) is complete
 	isMigrated, err := receiptsmigration.Done(paths)
 	if err != nil {
@@ -113,9 +144,18 @@ func preRun(cmd *cobra.Command, _ []string) error {
 			klog.Warningf("You may need to clean them up manually. Error: %v", err)
 		}
 	}
+
 	return nil
 }
 
+func showUpgradeNotification(*cobra.Command, []string) {
+	if latestTag == "" || latestTag == version.GitTag() {
+		klog.V(4).Infof("Skipping upgrade notification (latest=%q, current=%q)", latestTag, version.GitTag())
+		return
+	}
+	color.New(color.Bold).Fprintf(os.Stderr, upgradeNotification, version.GitTag(), latestTag)
+}
+
 func cleanupStaleKrewInstallations() error {
 	r, err := receipt.Load(paths.PluginInstallReceiptPath(constants.KrewPluginName))
 	if os.IsNotExist(err) {
@@ -152,3 +192,10 @@ func ensureDirs(paths ...string) error {
 func isTerminal(f *os.File) bool {
 	return isatty.IsTerminal(f.Fd()) || isatty.IsCygwinTerminal(f.Fd())
 }
+
+// isDevelopmentBuild tries to parse this builds tag as semver.
+// If it fails, this usually means that this is a development build.
+func isDevelopmentBuild() bool {
+	_, err := semver.Parse(version.GitTag())
+	return err != nil
+}

docs/USER_GUIDE.md

@@ -122,3 +122,13 @@ And delete the directory listed in `BasePath:` field. On macOS/Linux systems,
 deleting the installation location can be done by executing:
 
     rm -rf ~/.krew
+
+
+## Disabling update checks
+
+When using krew, it will occasionally check if a new version of krew is available
+by calling the GitHub API. If you want to opt out of this feature, you can set
+the `KREW_NO_UPGRADE_CHECK` environment variable. To permanently disable this,
+add the following to your `~/.bashrc`, `~/.bash_profile`, or `~/.zshrc`:
+
+    export KREW_NO_UPGRADE_CHECK=1

integration_test/testutil_test.go

@@ -70,6 +70,7 @@ func NewTest(t *testing.T) (*ITest, func()) {
 			fmt.Sprintf("PATH=%s", augmentPATH(t, binDir)),
 			"KREW_OS=linux",
 			"KREW_ARCH=amd64",
+			"KREW_NO_UPGRADE_CHECK=1",
 		},
 		tempDir: tempDir,
 	}, cleanup