// initConfig reads in config file and ENV variables if set.
func initConfig() {
configPath := constants.MakeMiniPath("config")
viper.SetConfigName("config")
viper.AddConfigPath(configPath)
err := viper.ReadInConfig()
if err != nil {
glog.Warningf("Error reading config file at %s: %s", configPath, err)
}
setupViper()
}
// 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, err
}
ip, err := host.Driver.GetIP()
if err != nil {
return nil, err
}
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 runStart(cmd *cobra.Command, args []string) {
fmt.Println("Starting local OpenShift 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),
DeployRouter: viper.GetBool(deployRouter),
DeployRegistry: viper.GetBool(deployRegistry),
}
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)
os.Exit(1)
}
if err := cluster.UpdateCluster(host.Driver); err != nil {
glog.Errorln("Error updating cluster: ", err)
os.Exit(1)
}
kubeIP, err := host.Driver.GetIP()
if err != nil {
glog.Errorln("Error connecting to cluster: ", err)
os.Exit(1)
}
if err := cluster.StartCluster(host, kubeIP, config); 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)
os.Exit(1)
}
kubeHost = strings.Replace(kubeHost, "tcp://", "https://", -1)
kubeHost = strings.Replace(kubeHost, ":2376", ":"+strconv.Itoa(constants.APIServerPort), -1)
// setup kubeconfig
certAuth, err := cluster.GetCA(host)
if err != nil {
glog.Errorln("Error setting up kubeconfig: ", err)
os.Exit(1)
}
if err := setupKubeconfig(kubeHost, certAuth); err != nil {
glog.Errorln("Error setting up kubeconfig: ", err)
os.Exit(1)
}
}
t, err := template.New("serviceURL").Parse(serviceURLFormat)
if err != nil {
fmt.Fprintln(os.Stderr, "The value passed to --format is invalid:\n\n", err)
os.Exit(1)
}
serviceURLTemplate = t
},
Run: func(cmd *cobra.Command, args []string) {
if len(args) == 0 || len(args) > 1 {
fmt.Fprintln(os.Stderr, "Please specify a service name.")
os.Exit(1)
}
service := args[0]
api := libmachine.NewClient(constants.Minipath, constants.MakeMiniPath("certs"))
defer api.Close()
url, err := cluster.GetServiceURL(api, namespace, service, serviceURLTemplate)
if err != nil {
fmt.Fprintln(os.Stderr, err)
if _, ok := err.(cluster.MissingNodePortError); !ok {
fmt.Fprintln(os.Stderr, "Check that minishift is running and that you have specified the correct namespace (-n flag).")
}
os.Exit(1)
}
if https {
url = strings.Replace(url, "http", "https", 1)
}
if serviceURLMode {
"io/ioutil"
"os"
"github.com/docker/machine/libmachine/log"
"github.com/golang/glog"
"github.com/jimmidyson/minishift/pkg/minikube/config"
"github.com/jimmidyson/minishift/pkg/minikube/constants"
"github.com/jimmidyson/minishift/pkg/minikube/update"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
"github.com/spf13/viper"
)
var dirs = [...]string{
constants.Minipath,
constants.MakeMiniPath("certs"),
constants.MakeMiniPath("machines"),
constants.MakeMiniPath("cache"),
constants.MakeMiniPath("cache", "iso"),
constants.MakeMiniPath("config")}
const (
showLibmachineLogs = "show-libmachine-logs"
)
var (
enableUpdateNotification = true
)
var viperWhiteList = []string{
"v",
update "github.com/inconshreveable/go-update"
"github.com/jimmidyson/minishift/pkg/minikube/config"
"github.com/jimmidyson/minishift/pkg/minikube/constants"
"github.com/jimmidyson/minishift/pkg/version"
"github.com/kardianos/osext"
"github.com/spf13/viper"
)
const (
timeLayout = time.RFC1123
githubOwner = "jimmidyson"
githubRepo = "minishift"
)
var (
lastUpdateCheckFilePath = constants.MakeMiniPath("last_update_check")
githubClient *github.Client
)
func MaybeUpdateFromGithub(output io.Writer) {
localVersion, err := version.GetSemverVersion()
if err != nil {
glog.Errorln(err)
return
}
MaybeUpdate(output, githubOwner, githubRepo, githubRepo, lastUpdateCheckFilePath, localVersion)
}
func MaybeUpdate(output io.Writer, githubOwner, githubRepo, binaryName, lastUpdatePath string, localVersion semver.Version) {
downloadBinary := binaryName + "-" + runtime.GOOS + "-" + runtime.GOARCH