// StartHost starts a host VM.
func StartHost(api libmachine.API, config MachineConfig) (*host.Host, error) {
exists, err := api.Exists(constants.MachineName)
if err != nil {
return nil, errors.Wrapf(err, "Error checking if host exists: %s", constants.MachineName)
}
if !exists {
return createHost(api, config)
}
glog.Infoln("Machine exists!")
h, err := api.Load(constants.MachineName)
if err != nil {
return nil, errors.Wrap(err, "Error loading existing host. Please try running [minikube delete], then run [minikube start] again.")
}
s, err := h.Driver.GetState()
glog.Infoln("Machine state: ", s)
if err != nil {
return nil, errors.Wrap(err, "Error getting state for host")
}
if s != state.Running {
if err := h.Driver.Start(); err != nil {
return nil, errors.Wrapf(err, "Error starting stopped host")
}
if err := api.Save(h); err != nil {
return nil, errors.Wrapf(err, "Error saving started host")
}
}
if err := h.ConfigureAuth(); err != nil {
return nil, errors.Wrap(err, "Error configuring auth on host: %s")
}
return h, nil
}
// StartHost starts a host VM.
func StartHost(api libmachine.API, config MachineConfig) (*host.Host, error) {
if exists, err := api.Exists(constants.MachineName); err != nil {
return nil, fmt.Errorf("Error checking if host exists: %s", err)
} else if exists {
glog.Infoln("Machine exists!")
h, err := api.Load(constants.MachineName)
if err != nil {
return nil, fmt.Errorf("Error loading existing host: %s", err)
}
s, err := h.Driver.GetState()
if err != nil {
return nil, fmt.Errorf("Error getting state for host: %s", err)
}
if s != state.Running {
if err := h.Driver.Start(); err != nil {
return nil, fmt.Errorf("Error starting stopped host: %s", err)
}
if err := api.Save(h); err != nil {
return nil, fmt.Errorf("Error saving started host: %s", err)
}
}
return h, nil
} else {
return createHost(api, config)
}
}
func removeLocalMachine(hostName string, api libmachine.API) error {
exist, _ := api.Exists(hostName)
if !exist {
return errors.New(hostName + " does not exist.")
}
return api.Remove(hostName)
}
// Remove removes a Docker Machine
func Remove(api libmachine.API, args map[string]string, form map[string][]string) (interface{}, error) {
name, present := args["name"]
if !present {
return nil, errRequireMachineName
}
exist, _ := api.Exists(name)
if !exist {
return Success{"removed", name}, nil
}
currentHost, err := api.Load(name)
if err != nil {
return nil, err
}
if err := currentHost.Driver.Remove(); err != nil {
return nil, err
}
if err := api.Remove(name); err != nil {
return nil, err
}
return Success{"removed", name}, nil
}
func checkIfApiExistsAndLoad(api libmachine.API) (*host.Host, error) {
exists, err := api.Exists(constants.MachineName)
if err != nil {
return nil, errors.Wrapf(err, "Error checking that api exists for: ", constants.MachineName)
}
if !exists {
return nil, errors.Errorf("Machine does not exist for api.Exists(%s)", constants.MachineName)
}
host, err := api.Load(constants.MachineName)
if err != nil {
return nil, errors.Wrapf(err, "Error loading api for: ", constants.MachineName)
}
return host, nil
}
func checkIfApiExistsAndLoad(api libmachine.API) (*host.Host, error) {
exists, err := api.Exists(constants.MachineName)
if err != nil {
return nil, err
}
if !exists {
return nil, fmt.Errorf("Machine does not exist for api.Exists(%s)", constants.MachineName)
}
host, err := api.Load(constants.MachineName)
if err != nil {
return nil, err
}
return host, nil
}
// targetHost returns a specific host name if one is indicated by the first CLI
// arg, or the default host name if no host is specified.
func targetHost(c CommandLine, api libmachine.API) (string, error) {
if len(c.Args()) == 0 {
defaultExists, err := api.Exists(defaultMachineName)
if err != nil {
return "", fmt.Errorf("Error checking if host %q exists: %s", defaultMachineName, err)
}
if defaultExists {
return defaultMachineName, nil
}
return "", ErrNoDefault
}
return c.Args()[0], nil
}
// GetHostStatus gets the status of the host VM.
func GetHostStatus(api libmachine.API) (string, error) {
dne := "Does Not Exist"
exists, err := api.Exists(constants.MachineName)
if err != nil {
return "", err
}
if !exists {
return dne, nil
}
host, err := api.Load(constants.MachineName)
if err != nil {
return "", err
}
s, err := host.Driver.GetState()
if s.String() == "" {
return dne, err
}
return s.String(), err
}
// GetHostStatus gets the status of the host VM.
func GetHostStatus(api libmachine.API) (string, error) {
dne := "Does Not Exist"
exists, err := api.Exists(constants.MachineName)
if err != nil {
return "", errors.Wrapf(err, "Error checking that api exists for: ", constants.MachineName)
}
if !exists {
return dne, nil
}
host, err := api.Load(constants.MachineName)
if err != nil {
return "", errors.Wrapf(err, "Error loading api for: ", constants.MachineName)
}
s, err := host.Driver.GetState()
if s.String() == "" {
return dne, nil
}
if err != nil {
return "", errors.Wrap(err, "Error getting host state")
}
return s.String(), nil
}
func cmdCreateInner(c CommandLine, api libmachine.API) error {
if len(c.Args()) > 1 {
return fmt.Errorf("Invalid command line. Found extra arguments %v", c.Args()[1:])
}
name := c.Args().First()
if name == "" {
c.ShowHelp()
return errNoMachineName
}
validName := host.ValidateHostName(name)
if !validName {
return fmt.Errorf("Error creating machine: %s", mcnerror.ErrInvalidHostname)
}
if err := validateSwarmDiscovery(c.String("swarm-discovery")); err != nil {
return fmt.Errorf("Error parsing swarm discovery: %s", err)
}
// TODO: Fix hacky JSON solution
rawDriver, err := json.Marshal(&drivers.BaseDriver{
MachineName: name,
StorePath: c.GlobalString("storage-path"),
})
if err != nil {
return fmt.Errorf("Error attempting to marshal bare driver data: %s", err)
}
driverName := c.String("driver")
h, err := api.NewHost(driverName, rawDriver)
if err != nil {
return fmt.Errorf("Error getting new host: %s", err)
}
h.HostOptions = &host.Options{
AuthOptions: &auth.Options{
CertDir: mcndirs.GetMachineCertDir(),
CaCertPath: tlsPath(c, "tls-ca-cert", "ca.pem"),
CaPrivateKeyPath: tlsPath(c, "tls-ca-key", "ca-key.pem"),
ClientCertPath: tlsPath(c, "tls-client-cert", "cert.pem"),
ClientKeyPath: tlsPath(c, "tls-client-key", "key.pem"),
ServerCertPath: filepath.Join(mcndirs.GetMachineDir(), name, "server.pem"),
ServerKeyPath: filepath.Join(mcndirs.GetMachineDir(), name, "server-key.pem"),
StorePath: filepath.Join(mcndirs.GetMachineDir(), name),
ServerCertSANs: c.StringSlice("tls-san"),
},
EngineOptions: &engine.Options{
ArbitraryFlags: c.StringSlice("engine-opt"),
Env: c.StringSlice("engine-env"),
InsecureRegistry: c.StringSlice("engine-insecure-registry"),
Labels: c.StringSlice("engine-label"),
RegistryMirror: c.StringSlice("engine-registry-mirror"),
StorageDriver: c.String("engine-storage-driver"),
TLSVerify: true,
InstallURL: c.String("engine-install-url"),
},
SwarmOptions: &swarm.Options{
IsSwarm: c.Bool("swarm") || c.Bool("swarm-master"),
Image: c.String("swarm-image"),
Agent: c.Bool("swarm"),
Master: c.Bool("swarm-master"),
Discovery: c.String("swarm-discovery"),
Address: c.String("swarm-addr"),
Host: c.String("swarm-host"),
Strategy: c.String("swarm-strategy"),
ArbitraryFlags: c.StringSlice("swarm-opt"),
ArbitraryJoinFlags: c.StringSlice("swarm-join-opt"),
IsExperimental: c.Bool("swarm-experimental"),
},
}
exists, err := api.Exists(h.Name)
if err != nil {
return fmt.Errorf("Error checking if host exists: %s", err)
}
if exists {
return mcnerror.ErrHostAlreadyExists{
Name: h.Name,
}
}
// driverOpts is the actual data we send over the wire to set the
// driver parameters (an interface fulfilling drivers.DriverOptions,
// concrete type rpcdriver.RpcFlags).
mcnFlags := h.Driver.GetCreateFlags()
driverOpts := getDriverOpts(c, mcnFlags)
if err := h.Driver.SetConfigFromFlags(driverOpts); err != nil {
return fmt.Errorf("Error setting machine configuration from flags provided: %s", err)
}
if err := api.Create(h); err != nil {
// Wait for all the logs to reach the client
time.Sleep(2 * time.Second)
vBoxLog := ""
if h.DriverName == "virtualbox" {
vBoxLog = filepath.Join(api.GetMachinesDir(), h.Name, h.Name, "Logs", "VBox.log")
}
return crashreport.CrashError{
Cause: err,
Command: "Create",
Context: "api.performCreate",
DriverName: h.DriverName,
LogFilePath: vBoxLog,
}
}
if err := api.Save(h); err != nil {
return fmt.Errorf("Error attempting to save store: %s", err)
}
log.Infof("To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: %s env %s", os.Args[0], name)
return nil
}
// Exists tells whether a named host exists.
func Exists(api libmachine.API, name string) bool {
exists, _ := api.Exists(name)
return exists
}
func cmdCreateInner(c CommandLine, api libmachine.API) error {
if len(c.Args()) > 1 {
return fmt.Errorf("Invalid command line. Found extra arguments %v", c.Args()[1:])
}
name := c.Args().First()
if name == "" {
c.ShowHelp()
return errNoMachineName
}
validName := host.ValidateHostName(name)
if !validName {
return fmt.Errorf("Error creating machine: %s", mcnerror.ErrInvalidHostname)
}
if err := validateSwarmDiscovery(c.String("swarm-discovery")); err != nil {
return fmt.Errorf("Error parsing swarm discovery: %s", err)
}
// TODO: Fix hacky JSON solution
rawDriver, err := json.Marshal(&drivers.BaseDriver{
MachineName: name,
StorePath: c.GlobalString("storage-path"),
})
if err != nil {
return fmt.Errorf("Error attempting to marshal bare driver data: %s", err)
}
driverName := c.String("driver")
driver, err := api.NewPluginDriver(driverName, rawDriver)
if err != nil {
return fmt.Errorf("Error loading driver %q: %s", driverName, err)
}
h, err := api.NewHost(driver)
if err != nil {
return fmt.Errorf("Error getting new host: %s", err)
}
certInfo := getCertPathInfoFromCommandLine(c)
h.HostOptions = &host.Options{
AuthOptions: &auth.Options{
CertDir: mcndirs.GetMachineCertDir(),
CaCertPath: certInfo.CaCertPath,
CaPrivateKeyPath: certInfo.CaPrivateKeyPath,
ClientCertPath: certInfo.ClientCertPath,
ClientKeyPath: certInfo.ClientKeyPath,
ServerCertPath: filepath.Join(mcndirs.GetMachineDir(), name, "server.pem"),
ServerKeyPath: filepath.Join(mcndirs.GetMachineDir(), name, "server-key.pem"),
StorePath: filepath.Join(mcndirs.GetMachineDir(), name),
ServerCertSANs: c.StringSlice("tls-san"),
},
EngineOptions: &engine.Options{
ArbitraryFlags: c.StringSlice("engine-opt"),
Env: c.StringSlice("engine-env"),
InsecureRegistry: c.StringSlice("engine-insecure-registry"),
Labels: c.StringSlice("engine-label"),
RegistryMirror: c.StringSlice("engine-registry-mirror"),
StorageDriver: c.String("engine-storage-driver"),
TLSVerify: true,
InstallURL: c.String("engine-install-url"),
},
SwarmOptions: &swarm.Options{
IsSwarm: c.Bool("swarm"),
Image: c.String("swarm-image"),
Master: c.Bool("swarm-master"),
Discovery: c.String("swarm-discovery"),
Address: c.String("swarm-addr"),
Host: c.String("swarm-host"),
Strategy: c.String("swarm-strategy"),
ArbitraryFlags: c.StringSlice("swarm-opt"),
},
}
exists, err := api.Exists(h.Name)
if err != nil {
return fmt.Errorf("Error checking if host exists: %s", err)
}
if exists {
return mcnerror.ErrHostAlreadyExists{
Name: h.Name,
}
}
// driverOpts is the actual data we send over the wire to set the
// driver parameters (an interface fulfilling drivers.DriverOptions,
// concrete type rpcdriver.RpcFlags).
mcnFlags := driver.GetCreateFlags()
driverOpts := getDriverOpts(c, mcnFlags)
if err := h.Driver.SetConfigFromFlags(driverOpts); err != nil {
return fmt.Errorf("Error setting machine configuration from flags provided: %s", err)
}
if err := api.Create(h); err != nil {
return fmt.Errorf("Error creating machine: %s", err)
}
if err := api.Save(h); err != nil {
return fmt.Errorf("Error attempting to save store: %s", err)
}
log.Infof("To see how to connect Docker to this machine, run: %s", fmt.Sprintf("%s env %s", os.Args[0], name))
return nil
}
func createMachine(api libmachine.API, name string, driver string, form map[string][]string) error {
validName := host.ValidateHostName(name)
if !validName {
return fmt.Errorf("Error creating machine: %s", mcnerror.ErrInvalidHostname)
}
exists, err := api.Exists(name)
if err != nil {
return fmt.Errorf("Error checking if host exists: %s", err)
}
if exists {
return mcnerror.ErrHostAlreadyExists{
Name: name,
}
}
rawDriver, err := json.Marshal(&drivers.BaseDriver{
MachineName: name,
StorePath: mcndirs.GetBaseDir(),
})
if err != nil {
return fmt.Errorf("Error attempting to marshal bare driver data: %s", err)
}
h, err := api.NewHost(driver, rawDriver)
if err != nil {
return err
}
globalOpts := globalFlags{
flags: form,
}
h.HostOptions = &host.Options{
AuthOptions: &auth.Options{
CertDir: mcndirs.GetMachineCertDir(),
CaCertPath: filepath.Join(mcndirs.GetMachineCertDir(), "ca.pem"),
CaPrivateKeyPath: filepath.Join(mcndirs.GetMachineCertDir(), "ca-key.pem"),
ClientCertPath: filepath.Join(mcndirs.GetMachineCertDir(), "cert.pem"),
ClientKeyPath: filepath.Join(mcndirs.GetMachineCertDir(), "key.pem"),
ServerCertPath: filepath.Join(mcndirs.GetMachineDir(), name, "server.pem"),
ServerKeyPath: filepath.Join(mcndirs.GetMachineDir(), name, "server-key.pem"),
StorePath: filepath.Join(mcndirs.GetMachineDir(), name),
ServerCertSANs: globalOpts.StringSlice("tls-san"),
},
EngineOptions: &engine.Options{
ArbitraryFlags: globalOpts.StringSlice("engine-opt"),
Env: globalOpts.StringSlice("engine-env"),
InsecureRegistry: globalOpts.StringSlice("engine-insecure-registry"),
Labels: globalOpts.StringSlice("engine-label"),
RegistryMirror: globalOpts.StringSlice("engine-registry-mirror"),
StorageDriver: globalOpts.String("engine-storage-driver"),
TLSVerify: true,
InstallURL: globalOpts.String("engine-install-url"),
},
SwarmOptions: &swarm.Options{
IsSwarm: globalOpts.Bool("swarm"),
Image: globalOpts.String("swarm-image"),
Master: globalOpts.Bool("swarm-master"),
Discovery: globalOpts.String("swarm-discovery"),
Address: globalOpts.String("swarm-addr"),
Host: globalOpts.String("swarm-host"),
Strategy: globalOpts.String("swarm-strategy"),
ArbitraryFlags: globalOpts.StringSlice("swarm-opt"),
IsExperimental: globalOpts.Bool("swarm-experimental"),
},
}
mcnFlags := h.Driver.GetCreateFlags()
opts, err := parseFlags(form, mcnFlags, commands.SharedCreateFlags)
if err != nil {
return err
}
if err := h.Driver.SetConfigFromFlags(opts); err != nil {
return fmt.Errorf("Error setting machine configuration from flags provided: %s", err)
}
if err := api.Create(h); err != nil {
return err
}
if err := api.Save(h); err != nil {
return fmt.Errorf("Error attempting to save store: %s", err)
}
return nil
}