Adds --manifest-url flag to allow plugin installation from remote manifests

cmd/krew/cmd/install.go

@@ -32,8 +32,8 @@ import (
 
 func init() {
 	var (
-		manifest, archiveFileOverride *string
-		noUpdateIndex                 *bool
+		manifest, manifestURL, archiveFileOverride *string
+		noUpdateIndex                              *bool
 	)
 
 	// installCmd represents the install command
@@ -62,6 +62,10 @@ Remarks:
 			var pluginNames = make([]string, len(args))
 			copy(pluginNames, args)
 
+			if *manifest != "" && *manifestURL != "" {
+				return errors.New("--manifest cannot be specified with --manifest-url")
+			}
+
 			if !isTerminal(os.Stdin) && (len(pluginNames) != 0 || *manifest != "") {
 				fmt.Fprintln(os.Stderr, "WARNING: Detected stdin, but discarding it because of --manifest or args")
 			}
@@ -81,8 +85,8 @@ Remarks:
 				return errors.New("must specify either specify either plugin names (via positional arguments or STDIN), or --manifest; not both")
 			}
 
-			if *archiveFileOverride != "" && *manifest == "" {
-				return errors.New("--archive can be specified only with --manifest")
+			if *archiveFileOverride != "" && *manifest == "" && *manifestURL == "" {
+				return errors.New("--archive can be specified only with --manifest or --manifest-url")
 			}
 
 			var install []index.Plugin
@@ -94,11 +98,14 @@ Remarks:
 				install = append(install, plugin)
 			}
 
-			if *manifest != "" {
-				plugin, err := indexscanner.ReadPluginFile(*manifest)
+			var plugin index.Plugin
+			if *manifest != "" || *manifestURL != "" {
+				var err error
+				plugin, err = internal.GetPlugin(*manifest, *manifestURL)
 				if err != nil {
 					return errors.Wrap(err, "failed to load custom manifest file")
 				}
+
 				if err := validation.ValidatePlugin(plugin.Name, plugin); err != nil {
 					return errors.Wrap(err, "plugin manifest validation error")
 				}
@@ -153,6 +160,7 @@ Remarks:
 	}
 
 	manifest = installCmd.Flags().String("manifest", "", "(Development-only) specify plugin manifest directly.")
+	manifestURL = installCmd.Flags().String("manifest-url", "", "(Development-only) specify plugin manifest URL directly.")
 	archiveFileOverride = installCmd.Flags().String("archive", "", "(Development-only) force all downloads to use the specified file")
 	noUpdateIndex = installCmd.Flags().Bool("no-update-index", false, "(Experimental) do not update local copy of plugin index before installing")
 

cmd/krew/cmd/internal/read_plugin.go

@@ -0,0 +1,49 @@
+// Copyright 2019 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"
+
+	"github.com/pkg/errors"
+
+	"sigs.k8s.io/krew/pkg/index"
+	"sigs.k8s.io/krew/pkg/index/indexscanner"
+)
+
+// readRemotePluginManifest returns the plugin for a remote manifest
+func readRemotePluginManifest(url string) (index.Plugin, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return index.Plugin{}, errors.Wrapf(err, "Error downloading manifest from %q", url)
+	}
+	defer resp.Body.Close()
+
+	plugin, err := indexscanner.DecodePluginFile(resp.Body)
+	if err != nil {
+		return index.Plugin{}, errors.Wrapf(err, "Error decoding manifest from %q", url)
+	}
+
+	return plugin, nil
+}
+
+// GetPlugin is an abstraction layer for manifest and manifest-url handlers and returns plugin object
+func GetPlugin(manifest string, manifestURL string) (index.Plugin, error) {
+	if manifest != "" {
+		return indexscanner.ReadPluginFile(manifest)
+	}
+
+	return readRemotePluginManifest(manifestURL)
+}

integration_test/install_test.go

@@ -15,6 +15,9 @@
 package integrationtest
 
 import (
+	"net"
+	"net/http"
+	"net/http/httptest"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -28,6 +31,7 @@ const (
 
 func TestKrewInstall(t *testing.T) {
 	skipShort(t)
+
 	test, cleanup := NewTest(t)
 	defer cleanup()
 
@@ -105,6 +109,115 @@ func TestKrewInstall_Manifest(t *testing.T) {
 	test.AssertExecutableInPATH("kubectl-" + validPlugin)
 }
 
+func startLocalServer(t *testing.T) (*httptest.Server, string) {
+	t.Helper()
+
+	server := httptest.NewUnstartedServer(http.FileServer(http.Dir("testdata")))
+
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("trouble starting local server")
+	}
+	server.Listener = listener
+	server.Start()
+	return server, server.URL
+}
+
+func TestKrewInstall_ManifestURL(t *testing.T) {
+	skipShort(t)
+
+	server, baseURL := startLocalServer(t)
+	defer server.Close()
+
+	test, cleanup := NewTest(t)
+	defer cleanup()
+
+	test.Krew("install",
+		"--manifest-url", baseURL+manifestURI).RunOrFail()
+	test.AssertExecutableInPATH("kubectl-" + validPlugin)
+}
+
+func TestKrewInstall_ManifestURLAndArchive(t *testing.T) {
+	skipShort(t)
+
+	server, baseURL := startLocalServer(t)
+	defer server.Close()
+
+	test, cleanup := NewTest(t)
+	defer cleanup()
+
+	test.Krew("install",
+		"--manifest-url", baseURL+archiveManifestURI,
+		"--archive", filepath.Join("testdata", fooPlugin+".tar.gz")).
+		RunOrFail()
+	test.AssertExecutableInPATH("kubectl-" + fooPlugin)
+}
+
+func TestKrewInstall_ManifestURLAndManifest(t *testing.T) {
+	skipShort(t)
+
+	server, baseURL := startLocalServer(t)
+	defer server.Close()
+
+	test, cleanup := NewTest(t)
+	defer cleanup()
+
+	err := test.Krew("install",
+		"--manifest-url", baseURL+manifestURI,
+		"--manifest", filepath.Join("testdata", fooPlugin+constants.ManifestExtension)).Run()
+	if err == nil {
+		t.Errorf("expected install to fail but was successful")
+	}
+}
+
+func TestKrewInstall_EmptyManifestURL(t *testing.T) {
+	skipShort(t)
+
+	server, baseURL := startLocalServer(t)
+	defer server.Close()
+
+	test, cleanup := NewTest(t)
+	defer cleanup()
+
+	err := test.Krew("install",
+		"--manifest-url", baseURL+emtpyManifestURI).Run()
+	if err == nil {
+		t.Errorf("expected install to fail but was successful")
+	}
+}
+
+func TestKrewInstall_InvalidManifestURL(t *testing.T) {
+	skipShort(t)
+
+	server, baseURL := startLocalServer(t)
+	defer server.Close()
+
+	test, cleanup := NewTest(t)
+	defer cleanup()
+
+	err := test.Krew("install",
+		"--manifest-url", baseURL+invalidManifestURI).Run()
+	if err == nil {
+		t.Errorf("expected install to fail but was successful")
+	}
+}
+
+func TestKrewInstall_NotExistManifestURL(t *testing.T) {
+	skipShort(t)
+
+	server, baseURL := startLocalServer(t)
+	defer server.Close()
+
+	test, cleanup := NewTest(t)
+	defer cleanup()
+
+	err := test.Krew("install",
+		"--manifest-url", baseURL+notExistManifestURI).Run()
+	if err == nil {
+		t.Errorf("expected install to fail but was successful")
+	}
+}
+
 func TestKrewInstall_ManifestAndArchive(t *testing.T) {
 	skipShort(t)
 
@@ -128,7 +241,7 @@ func TestKrewInstall_OnlyArchive(t *testing.T) {
 		"--archive", filepath.Join("testdata", fooPlugin+".tar.gz")).
 		Run()
 	if err == nil {
-		t.Errorf("Expected install to fail but was successful")
+		t.Errorf("expected install to fail but was successful")
 	}
 }
 

integration_test/testdata/invalid.yaml

@@ -0,0 +1,2 @@
+apiVersion: krew.googlecontainertools.github.com/v1alpha2
+kind; Plugin

integration_test/testutil_test.go

@@ -39,6 +39,11 @@ const (
 	krewBinaryEnv        = "KREW_BINARY"
 	validPlugin          = "konfig" // a plugin in central index with small size
 	validPlugin2         = "mtail"  // a plugin in central index with small size
+	manifestURI          = "/konfig.yaml"
+	emtpyManifestURI     = "/empty.yaml"
+	invalidManifestURI   = "/invalid.yaml"
+	notExistManifestURI  = "/doesnotexist.yaml"
+	archiveManifestURI   = "/foo.yaml"
 )
 
 var (