func runStart(cmd *cobra.Command, args []string) {
fmt.Println("Starting local Kubernetes cluster...")
api := libmachine.NewClient(constants.Minipath, constants.MakeMiniPath("certs"))
defer api.Close()
config := cluster.MachineConfig{
MinikubeISO: minikubeISO,
Memory: memory,
CPUs: cpus,
DiskSize: int(*disk / units.MB),
VMDriver: vmDriver,
DockerEnv: dockerEnv,
InsecureRegistry: insecureRegistry,
}
var host *host.Host
start := func() (err error) {
host, err = cluster.StartHost(api, config)
return err
}
err := util.Retry(3, start)
if err != nil {
glog.Errorln("Error starting host: ", err)
os.Exit(1)
}
if err := cluster.UpdateCluster(host.Driver); err != nil {
glog.Errorln("Error updating cluster: ", err)
os.Exit(1)
}
if err := cluster.SetupCerts(host.Driver); err != nil {
glog.Errorln("Error configuring authentication: ", err)
os.Exit(1)
}
if err := cluster.StartCluster(host); err != nil {
glog.Errorln("Error starting cluster: ", err)
os.Exit(1)
}
kubeHost, err := host.Driver.GetURL()
if err != nil {
glog.Errorln("Error connecting to cluster: ", err)
}
kubeHost = strings.Replace(kubeHost, "tcp://", "https://", -1)
kubeHost = strings.Replace(kubeHost, ":2376", ":"+strconv.Itoa(constants.APIServerPort), -1)
fmt.Printf("Kubernetes is available at %s.\n", kubeHost)
// setup kubeconfig
name := constants.MinikubeContext
certAuth := constants.MakeMiniPath("ca.crt")
clientCert := constants.MakeMiniPath("apiserver.crt")
clientKey := constants.MakeMiniPath("apiserver.key")
if err := setupKubeconfig(name, kubeHost, certAuth, clientCert, clientKey); err != nil {
glog.Errorln("Error setting up kubeconfig: ", err)
os.Exit(1)
}
fmt.Println("Kubectl is now configured to use the cluster.")
}
func TestUpdateCustomAddons(t *testing.T) {
tempDir := tests.MakeTempDir()
os.Mkdir(constants.MakeMiniPath("addons", "subdir"), 0777)
defer os.RemoveAll(tempDir)
s, _ := tests.NewSSHServer()
port, err := s.Start()
if err != nil {
t.Fatalf("Error starting ssh server: %s", err)
}
h := tests.NewMockHost()
d := &tests.MockDriver{
Port: port,
BaseDriver: drivers.BaseDriver{
IPAddress: "127.0.0.1",
SSHKeyPath: "",
},
}
//write a file into ~/.minikube/addons
path := filepath.Join(constants.MakeMiniPath("addons"), "dir-addon.yaml")
testContent1 := []byte("CUSTOM ADDON TEST STRING#1, In Addons Dir")
err = ioutil.WriteFile(path, testContent1, 0644)
if err != nil {
t.Fatalf("Error writing custom addon: %s", err)
}
path = filepath.Join(constants.MakeMiniPath("addons", "subdir"), "subdir-addon.yaml")
testContent2 := []byte("CUSTOM ADDON TEST STRING#2, In Addons SubDir")
err = ioutil.WriteFile(path, testContent2, 0644)
if err != nil {
t.Fatalf("Error writing custom addon: %s", err)
}
//run update
kubernetesConfig := KubernetesConfig{
KubernetesVersion: constants.DefaultKubernetesVersion,
}
if err := UpdateCluster(h, d, kubernetesConfig); err != nil {
t.Fatalf("Error updating cluster: %s", err)
}
transferred := s.Transfers.Bytes()
//test that custom addons are transferred properly
if !bytes.Contains(transferred, testContent1) {
t.Fatalf("Custom addon not copied. Expected transfers to contain custom addon with content: %s. It was: %s", testContent1, transferred)
}
if !bytes.Contains(transferred, testContent2) {
t.Fatalf("Custom addon not copied. Expected transfers to contain custom addon with content: %s. It was: %s", testContent2, transferred)
}
}
// initConfig reads in config file and ENV variables if set.
func initConfig() {
viper.SetConfigName("config")
viper.AddConfigPath(constants.MakeMiniPath("config"))
viper.ReadInConfig()
viper.SetDefault(config.WantUpdateNotification, true)
viper.SetDefault(config.ReminderWaitPeriodInHours, 24)
}
func addMinikubeAddonsDirToAssets(assetList *[]CopyableFile) {
// loop over .minikube/addons and add them to assets
searchDir := constants.MakeMiniPath("addons")
err := filepath.Walk(searchDir, func(addonFile string, f os.FileInfo, err error) error {
isDir, err := util.IsDirectory(addonFile)
if err == nil && !isDir {
f, err := NewFileAsset(addonFile, "/etc/kubernetes/addons", filepath.Base(addonFile), "0640")
if err == nil {
*assetList = append(*assetList, f)
}
} else if err != nil {
glog.Infoln("Error encountered while walking .minikube/addons: ", err)
}
return nil
})
if err != nil {
glog.Infoln("Error encountered while walking .minikube/addons: ", err)
}
}
// GetHostDockerEnv gets the necessary docker env variables to allow the use of docker through minikube's vm
func GetHostDockerEnv(api libmachine.API) (map[string]string, error) {
host, err := checkIfApiExistsAndLoad(api)
if err != nil {
return nil, errors.Wrap(err, "Error checking that api exists and loading it")
}
ip, err := host.Driver.GetIP()
if err != nil {
return nil, errors.Wrap(err, "Error getting ip from host")
}
tcpPrefix := "tcp://"
portDelimiter := ":"
port := "2376"
envMap := map[string]string{
"DOCKER_TLS_VERIFY": "1",
"DOCKER_HOST": tcpPrefix + ip + portDelimiter + port,
"DOCKER_CERT_PATH": constants.MakeMiniPath("certs"),
}
return envMap, nil
}
func MaybePrintUpdateText(output io.Writer, url string, lastUpdatePath string) {
if !shouldCheckURLVersion(lastUpdatePath) {
return
}
latestVersion, err := getLatestVersionFromURL(url)
if err != nil {
glog.Errorln(err)
return
}
localVersion, err := version.GetSemverVersion()
if err != nil {
glog.Errorln(err)
return
}
if localVersion.Compare(latestVersion) < 0 {
writeTimeToFile(lastUpdateCheckFilePath, time.Now().UTC())
fmt.Fprintf(output, `There is a newer version of minikube available (%s%s). Download it here:
%s%s
To disable this notification, add WantUpdateNotification: False to the json config file at %s
(you may have to create the file config.json in this folder if you have no previous configuration)\n`,
version.VersionPrefix, latestVersion, updateLinkPrefix, latestVersion, constants.MakeMiniPath("config"))
}
}
// otherwise default to allcaps HTTP_PROXY
if noProxyValue == "" {
noProxyVar = "NO_PROXY"
noProxyValue = os.Getenv("NO_PROXY")
}
return noProxyVar, noProxyValue
}
// envCmd represents the docker-env command
var dockerEnvCmd = &cobra.Command{
Use: "docker-env",
Short: "sets up docker env variables; similar to '$(docker-machine env)'",
Long: `sets up docker env variables; similar to '$(docker-machine env)'`,
Run: func(cmd *cobra.Command, args []string) {
api := libmachine.NewClient(constants.Minipath, constants.MakeMiniPath("certs"))
defer api.Close()
var (
err error
shellCfg *ShellConfig
)
if unset {
shellCfg, err = shellCfgUnset(api)
if err != nil {
glog.Errorln("Error setting machine env variable(s):", err)
os.Exit(1)
}
} else {
shellCfg, err = shellCfgSet(api)
"strings"
"time"
"github.com/blang/semver"
"github.com/golang/glog"
"github.com/spf13/viper"
"k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/minikube/constants"
"k8s.io/minikube/pkg/version"
)
const updateLinkPrefix = "https://github.com/kubernetes/minikube/releases/tag/v"
var (
timeLayout = time.RFC1123
lastUpdateCheckFilePath = constants.MakeMiniPath("last_update_check")
githubMinikubeReleasesURL = "https://api.github.com/repos/kubernetes/minikube/releases"
)
func MaybePrintUpdateTextFromGithub(output io.Writer) {
MaybePrintUpdateText(output, githubMinikubeReleasesURL, lastUpdateCheckFilePath)
}
func MaybePrintUpdateText(output io.Writer, url string, lastUpdatePath string) {
if !shouldCheckURLVersion(lastUpdatePath) {
return
}
latestVersion, err := getLatestVersionFromURL(url)
if err != nil {
glog.Errorln(err)
return
"strings"
"github.com/docker/machine/libmachine/log"
"github.com/golang/glog"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
"github.com/spf13/viper"
configCmd "k8s.io/minikube/cmd/minikube/cmd/config"
"k8s.io/minikube/pkg/minikube/config"
"k8s.io/minikube/pkg/minikube/constants"
"k8s.io/minikube/pkg/minikube/notify"
)
var dirs = [...]string{
constants.Minipath,
constants.MakeMiniPath("certs"),
constants.MakeMiniPath("machines"),
constants.MakeMiniPath("cache"),
constants.MakeMiniPath("cache", "iso"),
constants.MakeMiniPath("cache", "localkube"),
constants.MakeMiniPath("config"),
constants.MakeMiniPath("addons"),
}
const (
showLibmachineLogs = "show-libmachine-logs"
)
var (
enableUpdateNotification = true
)
func runStart(cmd *cobra.Command, args []string) {
fmt.Println("Starting local Kubernetes cluster...")
api := libmachine.NewClient(constants.Minipath, constants.MakeMiniPath("certs"))
defer api.Close()
config := cluster.MachineConfig{
MinikubeISO: viper.GetString(isoURL),
Memory: viper.GetInt(memory),
CPUs: viper.GetInt(cpus),
DiskSize: calculateDiskSizeInMB(viper.GetString(humanReadableDiskSize)),
VMDriver: viper.GetString(vmDriver),
DockerEnv: dockerEnv,
InsecureRegistry: insecureRegistry,
RegistryMirror: registryMirror,
HostOnlyCIDR: viper.GetString(hostOnlyCIDR),
}
var host *host.Host
start := func() (err error) {
host, err = cluster.StartHost(api, config)
if err != nil {
glog.Errorf("Error starting host: %s. Retrying.\n", err)
}
return err
}
err := util.Retry(3, start)
if err != nil {
glog.Errorln("Error starting host: ", err)
util.MaybeReportErrorAndExit(err)
}
ip, err := host.Driver.GetIP()
if err != nil {
glog.Errorln("Error starting host: ", err)
util.MaybeReportErrorAndExit(err)
}
kubernetesConfig := cluster.KubernetesConfig{
KubernetesVersion: viper.GetString(kubernetesVersion),
NodeIP: ip,
ContainerRuntime: viper.GetString(containerRuntime),
NetworkPlugin: viper.GetString(networkPlugin),
}
if err := cluster.UpdateCluster(host, host.Driver, kubernetesConfig); err != nil {
glog.Errorln("Error updating cluster: ", err)
util.MaybeReportErrorAndExit(err)
}
if err := cluster.SetupCerts(host.Driver); err != nil {
glog.Errorln("Error configuring authentication: ", err)
util.MaybeReportErrorAndExit(err)
}
if err := cluster.StartCluster(host, kubernetesConfig); err != nil {
glog.Errorln("Error starting cluster: ", err)
util.MaybeReportErrorAndExit(err)
}
kubeHost, err := host.Driver.GetURL()
if err != nil {
glog.Errorln("Error connecting to cluster: ", err)
}
kubeHost = strings.Replace(kubeHost, "tcp://", "https://", -1)
kubeHost = strings.Replace(kubeHost, ":2376", ":"+strconv.Itoa(constants.APIServerPort), -1)
// setup kubeconfig
name := constants.MinikubeContext
certAuth := constants.MakeMiniPath("ca.crt")
clientCert := constants.MakeMiniPath("apiserver.crt")
clientKey := constants.MakeMiniPath("apiserver.key")
if err := setupKubeconfig(name, kubeHost, certAuth, clientCert, clientKey); err != nil {
glog.Errorln("Error setting up kubeconfig: ", err)
util.MaybeReportErrorAndExit(err)
}
fmt.Println("Kubectl is now configured to use the cluster.")
}