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.") }