Merge pull request #438 from aaron-prindle/cache-localkube

Added localkube caching functionality.  Also cleanup up private/public

LOCALKUBE_RELEASING.md

@@ -30,11 +30,5 @@ This step makes the new release trigger update notifications in old versions of
 Use this command from a clean git repo:
 
 ```shell
-gsutil cp deploy/minikube/releases.json gs://minikube/k8s_releases.json
-```
-
-## Mark the release as `latest` in GCS:
-
-```shell
-gsutil cp -r gs://minikube/releases/$RELEASE gs://minikube/releases/latest
+gsutil cp deploy/minikube/k8s_releases.json gs://minikube/k8s_releases.json
 ```

pkg/minikube/cluster/cluster.go

@@ -19,7 +19,6 @@ package cluster
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -39,7 +38,6 @@ import (
 	"github.com/docker/machine/libmachine/host"
 	"github.com/docker/machine/libmachine/state"
 	"github.com/golang/glog"
-	"golang.org/x/crypto/ssh"
 	kubeApi "k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/client/unversioned"
 	"k8s.io/kubernetes/pkg/client/unversioned/clientcmd"
@@ -211,49 +209,14 @@ var assets = []fileToCopy{
 	},
 }
 
-func updateLocalkubeFromURL(config KubernetesConfig, client *ssh.Client) error {
-	resp := &http.Response{}
-	err := errors.New("")
-	downloader := func() (err error) {
-		url, err := util.GetLocalkubeDownloadURL(config.KubernetesVersion,
-			constants.LocalkubeLinuxFilename)
-		if err != nil {
-			return err
-		}
-		resp, err = http.Get(url)
-		return err
-	}
-
-	if err = util.Retry(5, downloader); err != nil {
-		return err
-	}
-	if err = sshutil.Transfer(resp.Body, int(resp.ContentLength), "/usr/local/bin",
-		"localkube", "0777", client); err != nil {
-		return err
-	}
-	return nil
-}
-
-func updateLocalkubeFromAsset(client *ssh.Client) error {
-	contents, err := Asset("out/localkube")
-	if err != nil {
-		glog.Infof("Error loading asset out/localkube: %s", err)
-		return err
-	}
-	if err := sshutil.Transfer(bytes.NewReader(contents), len(contents), "/usr/local/bin",
-		"localkube", "0777", client); err != nil {
-		return err
-	}
-	return nil
-}
-
 func UpdateCluster(h sshAble, d drivers.Driver, config KubernetesConfig) error {
 	client, err := sshutil.NewSSHClient(d)
 	if err != nil {
 		return err
 	}
-	if localkubeURLWasSpecified(config) {
-		if err = updateLocalkubeFromURL(config, client); err != nil {
+	if localkubeURIWasSpecified(config) {
+		lCacher := localkubeCacher{config}
+		if err = lCacher.updateLocalkubeFromURI(client); err != nil {
 			return err
 		}
 	} else {
@@ -276,7 +239,7 @@ func UpdateCluster(h sshAble, d drivers.Driver, config KubernetesConfig) error {
 	return nil
 }
 
-func localkubeURLWasSpecified(config KubernetesConfig) bool {
+func localkubeURIWasSpecified(config KubernetesConfig) bool {
 	// see if flag is different than default -> it was passed by user
 	return config.KubernetesVersion != constants.DefaultKubernetesVersion
 }
@@ -391,6 +354,7 @@ func (m *MachineConfig) GetISOFileURI() string {
 	// As this is a file URL there should be no backslashes regardless of platform running on.
 	return "file://" + filepath.ToSlash(isoPath)
 }
+
 func (m *MachineConfig) IsMinikubeISOCached() bool {
 	if _, err := os.Stat(m.GetISOCacheFilepath()); os.IsNotExist(err) {
 		return false

pkg/minikube/cluster/cluster_test.go

@@ -534,6 +534,9 @@ func (h *K8sVersionHandlerCorrect) ServeHTTP(w http.ResponseWriter, r *http.Requ
 }
 
 func TestUpdateKubernetesVersion(t *testing.T) {
+	tempDir := tests.MakeTempDir()
+	defer os.RemoveAll(tempDir)
+
 	s, _ := tests.NewSSHServer()
 	port, err := s.Start()
 	if err != nil {
@@ -565,3 +568,48 @@ func TestUpdateKubernetesVersion(t *testing.T) {
 		t.Fatalf("File not copied. Expected transfers to contain: %s. It was: %s", contents, transferred)
 	}
 }
+
+type nopCloser struct {
+	io.Reader
+}
+
+func (nopCloser) Close() error { return nil }
+
+func TestIsLocalkubeCached(t *testing.T) {
+	tempDir := tests.MakeTempDir()
+	defer os.RemoveAll(tempDir)
+
+	inputArr := [...]string{
+		"v1.3.3",
+		"1.3.0",
+		"http://test-url.localkube.com/localkube-binary",
+		"file:///test/dir/to/localkube-binary",
+	}
+
+	readCloser := nopCloser{}
+
+	localkubeCacher := localkubeCacher{
+		k8sConf: KubernetesConfig{},
+	}
+
+	inner := func(input string) {
+		localkubeCacher.k8sConf = KubernetesConfig{
+			KubernetesVersion: input,
+		}
+		if localkubeCacher.isLocalkubeCached() {
+			t.Errorf("IsLocalKubeCached returned true even though %s was not cached",
+				localkubeCacher.getLocalkubeCacheFilepath())
+		}
+
+		readCloser = nopCloser{bytes.NewBufferString("test-localkube-binary-data")}
+		localkubeCacher.cacheLocalkube(readCloser)
+		if !localkubeCacher.isLocalkubeCached() {
+			t.Errorf("IsLocalKubeCached returned false even though %s was cached",
+				localkubeCacher.getLocalkubeCacheFilepath())
+		}
+
+	}
+	for _, input := range inputArr {
+		inner(input)
+	}
+}

pkg/minikube/cluster/localkube_caching.go

+/*
+Copyright 2016 The Kubernetes Authors All rights reserved.
+
+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 cluster
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/golang/glog"
+	"golang.org/x/crypto/ssh"
+	"k8s.io/minikube/pkg/minikube/constants"
+	"k8s.io/minikube/pkg/minikube/sshutil"
+	"k8s.io/minikube/pkg/util"
+)
+
+func updateLocalkubeFromAsset(client *ssh.Client) error {
+	contents, err := Asset("out/localkube")
+	if err != nil {
+		glog.Infof("Error loading asset out/localkube: %s", err)
+		return err
+	}
+	if err := sshutil.Transfer(bytes.NewReader(contents), len(contents), "/usr/local/bin",
+		"localkube", "0777", client); err != nil {
+		return err
+	}
+	return nil
+}
+
+// localkubeCacher is a struct with methods designed for caching localkube
+type localkubeCacher struct {
+	k8sConf KubernetesConfig
+}
+
+func (l *localkubeCacher) getLocalkubeCacheFilepath() string {
+	return filepath.Join(constants.Minipath, "cache", "localkube",
+		filepath.Base(url.QueryEscape("localkube-"+l.k8sConf.KubernetesVersion)))
+}
+
+func (l *localkubeCacher) isLocalkubeCached() bool {
+	if _, err := os.Stat(l.getLocalkubeCacheFilepath()); os.IsNotExist(err) {
+		return false
+	}
+	return true
+}
+
+func (l *localkubeCacher) cacheLocalkube(body io.ReadCloser) error {
+	// store localkube inside the .minikube dir
+	out, err := os.Create(l.getLocalkubeCacheFilepath())
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+	defer body.Close()
+	if _, err = io.Copy(out, body); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *localkubeCacher) downloadAndCacheLocalkube() error {
+	resp := &http.Response{}
+	err := errors.New("")
+	downloader := func() (err error) {
+		url, err := util.GetLocalkubeDownloadURL(l.k8sConf.KubernetesVersion,
+			constants.LocalkubeLinuxFilename)
+		if err != nil {
+			return err
+		}
+		resp, err = http.Get(url)
+		return err
+	}
+
+	if err = util.Retry(5, downloader); err != nil {
+		return err
+	}
+	if err = l.cacheLocalkube(resp.Body); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *localkubeCacher) updateLocalkubeFromURI(client *ssh.Client) error {
+	urlObj, err := url.Parse(l.k8sConf.KubernetesVersion)
+	if err != nil {
+		return err
+	}
+	if urlObj.Scheme == fileScheme {
+		return l.updateLocalkubeFromFile(client)
+	} else {
+		return l.updateLocalkubeFromURL(client)
+	}
+}
+
+func (l *localkubeCacher) updateLocalkubeFromURL(client *ssh.Client) error {
+	if !l.isLocalkubeCached() {
+		if err := l.downloadAndCacheLocalkube(); err != nil {
+			return err
+		}
+	}
+	if err := l.transferCachedLocalkubeToVM(client); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *localkubeCacher) transferCachedLocalkubeToVM(client *ssh.Client) error {
+	contents, err := ioutil.ReadFile(l.getLocalkubeCacheFilepath())
+	if err != nil {
+		glog.Infof("Error loading asset out/localkube: %s", err)
+		return err
+	}
+
+	if err = sshutil.Transfer(bytes.NewReader(contents), len(contents), "/usr/local/bin",
+		"localkube", "0777", client); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (l *localkubeCacher) updateLocalkubeFromFile(client *ssh.Client) error {
+	path := strings.TrimPrefix(l.k8sConf.KubernetesVersion, "file://")
+	path = filepath.FromSlash(path)
+	contents, err := ioutil.ReadFile(path)
+	if err != nil {
+		glog.Infof("Error loading file %s: %s", path, err)
+		return err
+	}
+	if err := sshutil.Transfer(bytes.NewReader(contents), len(contents), "/usr/local/bin",
+		"localkube", "0777", client); err != nil {
+		return err
+	}
+	return nil
+}