func NewDockerMachine(config DockerMachineConfig) (DockerMachineAPI, error) { storePath := config.StorePath temp := false if storePath == "" { tempPath, err := ioutil.TempDir("", "") if err != nil { return nil, errors.Wrap(err, "failed to create temp dir") } storePath = tempPath temp = true } certsPath := filepath.Join(storePath, "certs") if _, err := os.Stat(certsPath); os.IsNotExist(err) { err := os.MkdirAll(certsPath, 0700) if err != nil { return nil, errors.WithMessage(err, "failed to create certs dir") } } if config.CaPath != "" { err := mcnutils.CopyFile(filepath.Join(config.CaPath, "ca.pem"), filepath.Join(certsPath, "ca.pem")) if err != nil { return nil, errors.Wrap(err, "failed to copy ca file") } err = mcnutils.CopyFile(filepath.Join(config.CaPath, "ca-key.pem"), filepath.Join(certsPath, "ca-key.pem")) if err != nil { return nil, errors.Wrap(err, "failed to copy ca key file") } } if config.OutWriter != nil { log.SetOutWriter(config.OutWriter) } else { log.SetOutWriter(ioutil.Discard) } if config.ErrWriter != nil { log.SetOutWriter(config.ErrWriter) } else { log.SetOutWriter(ioutil.Discard) } log.SetDebug(config.IsDebug) client := libmachine.NewClient(storePath, certsPath) client.IsDebug = config.IsDebug if _, err := os.Stat(client.GetMachinesDir()); os.IsNotExist(err) { err := os.MkdirAll(client.GetMachinesDir(), 0700) if err != nil { return nil, errors.WithMessage(err, "failed to create machines dir") } } return &DockerMachine{ StorePath: storePath, CertsPath: certsPath, client: client, temp: temp, }, nil }
func cmdConfig(c CommandLine) error { // Ensure that log messages always go to stderr when this command is // being run (it is intended to be run in a subshell) log.SetOutWriter(os.Stderr) if len(c.Args()) != 1 { return ErrExpectedOneMachine } host, err := getFirstArgHost(c) if err != nil { return err } dockerHost, authOptions, err := runConnectionBoilerplate(host, c) if err != nil { return fmt.Errorf("Error running connection boilerplate: %s", err) } log.Debug(dockerHost) fmt.Printf("--tlsverify --tlscacert=%q --tlscert=%q --tlskey=%q -H=%s", authOptions.CaCertPath, authOptions.ClientCertPath, authOptions.ClientKeyPath, dockerHost) return nil }
func cmdConfig(c CommandLine, api libmachine.API) error { // Ensure that log messages always go to stderr when this command is // being run (it is intended to be run in a subshell) log.SetOutWriter(os.Stderr) if len(c.Args()) != 1 { return ErrExpectedOneMachine } host, err := api.Load(c.Args().First()) if err != nil { return err } dockerHost, authOptions, err := check.DefaultConnChecker.Check(host, c.Bool("swarm")) if err != nil { return fmt.Errorf("Error running connection boilerplate: %s", err) } log.Debug(dockerHost) fmt.Printf("--tlsverify\n--tlscacert=%q\n--tlscert=%q\n--tlskey=%q\n-H=%s\n", authOptions.CaCertPath, authOptions.ClientCertPath, authOptions.ClientKeyPath, dockerHost) return nil }
func cmdEnv(c CommandLine, api libmachine.API) error { // Ensure that log messages always go to stderr when this command is // being run (it is intended to be run in a subshell) log.SetOutWriter(os.Stderr) if c.Bool("unset") { return unset(c, api) } return set(c, api) }
func main() { log.IsDebug = true log.SetOutWriter(os.Stdout) log.SetErrWriter(os.Stderr) client := libmachine.NewClient("/tmp/automatic") hostName := "myfunhost" // Set some options on the provider... driver := virtualbox.NewDriver(hostName, "/tmp/automatic") driver.CPU = 2 driver.Memory = 2048 data, err := json.Marshal(driver) if err != nil { log.Fatal(err) } pluginDriver, err := client.NewPluginDriver("virtualbox", data) if err != nil { log.Fatal(err) } h, err := client.NewHost(pluginDriver) if err != nil { log.Fatal(err) } h.HostOptions.EngineOptions.StorageDriver = "overlay" if err := client.Create(h); err != nil { log.Fatal(err) } out, err := h.RunSSHCommand("df -h") if err != nil { log.Fatal(err) } fmt.Printf("Results of your disk space query:\n%s\n", out) fmt.Println("Powering down machine now...") if err := h.Stop(); err != nil { log.Fatal(err) } }
func main() { libmachine.SetDebug(true) log.SetOutWriter(os.Stdout) log.SetErrWriter(os.Stderr) // returns the familiar store at $HOME/.docker/machine store := libmachine.GetDefaultStore() // over-ride this for now (don't want to muck with my default store) store.Path = "/tmp/automatic" hostName := "myfunhost" // Set some options on the provider... driver := virtualbox.NewDriver(hostName, "/tmp/automatic") driver.CPU = 2 driver.Memory = 2048 h, err := store.NewHost(driver) if err != nil { log.Fatal(err) } h.HostOptions.EngineOptions.StorageDriver = "overlay" if err := libmachine.Create(store, h); err != nil { log.Fatal(err) } out, err := h.RunSSHCommand("df -h") if err != nil { log.Fatal(err) } fmt.Printf("Results of your disk space query:\n%s\n", out) fmt.Println("Powering down machine now...") if err := h.Stop(); err != nil { log.Fatal(err) } }
func cmdEnv(c CommandLine, api libmachine.API) error { var ( err error shellCfg *ShellConfig ) // Ensure that log messages always go to stderr when this command is // being run (it is intended to be run in a subshell) log.SetOutWriter(os.Stderr) if c.Bool("unset") { shellCfg, err = shellCfgUnset(c, api) if err != nil { return err } } else { shellCfg, err = shellCfgSet(c, api) if err != nil { return err } } return executeTemplateStdout(shellCfg) }
func cmdEnv(c *cli.Context) { // Ensure that log messages always go to stderr when this command is // being run (it is intended to be run in a subshell) log.SetOutWriter(os.Stderr) if len(c.Args()) != 1 && !c.Bool("unset") { fatal(improperEnvArgsError) } h := getFirstArgHost(c) dockerHost, authOptions, err := runConnectionBoilerplate(h, c) if err != nil { fatalf("Error running connection boilerplate: %s", err) } userShell := c.String("shell") if userShell == "" { shell, err := detectShell() if err != nil { fatal(err) } userShell = shell } t := template.New("envConfig") usageHint := generateUsageHint(c.App.Name, c.Args().First(), userShell, c.Bool("no-proxy"), c.Bool("swarm")) shellCfg := &ShellConfig{ DockerCertPath: authOptions.CertDir, DockerHost: dockerHost, DockerTLSVerify: "1", UsageHint: usageHint, MachineName: h.Name, } if c.Bool("no-proxy") { ip, err := h.Driver.GetIP() if err != nil { fatalf("Error getting host IP: %s", err) } // first check for an existing lower case no_proxy var noProxyVar := "no_proxy" noProxyValue := os.Getenv("no_proxy") // otherwise default to allcaps HTTP_PROXY if noProxyValue == "" { noProxyVar = "NO_PROXY" noProxyValue = os.Getenv("NO_PROXY") } // add the docker host to the no_proxy list idempotently switch { case noProxyValue == "": noProxyValue = ip case strings.Contains(noProxyValue, ip): //ip already in no_proxy list, nothing to do default: noProxyValue = fmt.Sprintf("%s,%s", noProxyValue, ip) } shellCfg.NoProxyVar = noProxyVar shellCfg.NoProxyValue = noProxyValue } // unset vars if c.Bool("unset") { switch userShell { case "fish": shellCfg.Prefix = "set -e " shellCfg.Delimiter = "" shellCfg.Suffix = ";\n" case "powershell": shellCfg.Prefix = "Remove-Item Env:\\\\" shellCfg.Delimiter = "" shellCfg.Suffix = "\n" case "cmd": // since there is no way to unset vars in cmd just reset to empty shellCfg.DockerCertPath = "" shellCfg.DockerHost = "" shellCfg.DockerTLSVerify = "" shellCfg.Prefix = "set " shellCfg.Delimiter = "=" shellCfg.Suffix = "\n" default: shellCfg.Prefix = "unset " shellCfg.Delimiter = " " shellCfg.Suffix = "\n" } tmpl, err := t.Parse(envTmpl) if err != nil { fatal(err) } if err := tmpl.Execute(os.Stdout, shellCfg); err != nil { fatal(err) } return } switch userShell { case "fish": shellCfg.Prefix = "set -x " shellCfg.Suffix = "\";\n" shellCfg.Delimiter = " \"" case "powershell": shellCfg.Prefix = "$Env:" shellCfg.Suffix = "\"\n" shellCfg.Delimiter = " = \"" case "cmd": shellCfg.Prefix = "set " shellCfg.Suffix = "\n" shellCfg.Delimiter = "=" default: shellCfg.Prefix = "export " shellCfg.Suffix = "\"\n" shellCfg.Delimiter = "=\"" } tmpl, err := t.Parse(envTmpl) if err != nil { fatal(err) } if err := tmpl.Execute(os.Stdout, shellCfg); err != nil { fatal(err) } }
var RootCmd = &cobra.Command{ Use: "minishift", Short: "Minishift is a tool for managing local OpenShift clusters.", Long: `Minishift is a CLI tool that provisions and manages single-node OpenShift clusters optimized for development workflows.`, PersistentPreRun: func(cmd *cobra.Command, args []string) { for _, path := range dirs { if err := os.MkdirAll(path, 0777); err != nil { glog.Exitf("Error creating minishift directory: %s", err) } } shouldShowLibmachineLogs := viper.GetBool(showLibmachineLogs) log.SetDebug(shouldShowLibmachineLogs) if !shouldShowLibmachineLogs { log.SetOutWriter(ioutil.Discard) log.SetErrWriter(ioutil.Discard) } if enableUpdateNotification { update.MaybeUpdateFromGithub(os.Stdout) } }, } // Execute adds all child commands to the root command sets flags appropriately. // This is called by main.main(). It only needs to happen once to the rootCmd. func Execute() { if err := RootCmd.Execute(); err != nil { glog.Exitln(err) }
func TestExecServer(t *testing.T) { log.IsDebug = true machineName := "test" logReader, logWriter := io.Pipe() log.SetOutWriter(logWriter) log.SetErrWriter(logWriter) defer func() { log.IsDebug = false log.SetOutWriter(os.Stdout) log.SetErrWriter(os.Stderr) }() stdoutReader, stdoutWriter := io.Pipe() stderrReader, stderrWriter := io.Pipe() fe := &FakeExecutor{ stdout: stdoutReader, stderr: stderrReader, } lbp := &Plugin{ MachineName: machineName, Executor: fe, addrCh: make(chan string, 1), stopCh: make(chan bool, 1), } finalErr := make(chan error) // Start the docker-machine-foo plugin server go func() { finalErr <- lbp.execServer() }() expectedAddr := "127.0.0.1:12345" expectedPluginOut := "Doing some fun plugin stuff..." expectedPluginErr := "Uh oh, something in plugin went wrong..." logScanner := bufio.NewScanner(logReader) if _, err := io.WriteString(stdoutWriter, expectedAddr+"\n"); err != nil { t.Fatalf("Error attempting to write plugin address: %s", err) } if addr := <-lbp.addrCh; addr != expectedAddr { t.Fatalf("Expected to read the expected address properly in server but did not") } expectedOut := fmt.Sprintf("%s%s", fmt.Sprintf(pluginOutPrefix, machineName), expectedPluginOut) if _, err := io.WriteString(stdoutWriter, expectedPluginOut+"\n"); err != nil { t.Fatalf("Error attempting to write to out in plugin: %s", err) } if logScanner.Scan(); logScanner.Text() != expectedOut { t.Fatalf("Output written to log was not what we expected\nexpected: %s\nactual: %s", expectedOut, logScanner.Text()) } expectedErr := fmt.Sprintf("%s%s", fmt.Sprintf(pluginErrPrefix, machineName), expectedPluginErr) if _, err := io.WriteString(stderrWriter, expectedPluginErr+"\n"); err != nil { t.Fatalf("Error attempting to write to err in plugin: %s", err) } if logScanner.Scan(); logScanner.Text() != expectedErr { t.Fatalf("Error written to log was not what we expected\nexpected: %s\nactual: %s", expectedErr, logScanner.Text()) } lbp.Close() if err := <-finalErr; err != nil { t.Fatalf("Error serving: %s", err) } }