func (h *Host) Create(name string) error { // create the instance if err := h.Driver.Create(); err != nil { return err } // save to store if err := h.SaveConfig(); err != nil { return err } // TODO: Not really a fan of just checking "none" here. if h.Driver.DriverName() != "none" { if err := utils.WaitFor(drivers.MachineInState(h.Driver, state.Running)); err != nil { return err } if err := WaitForSSH(h); err != nil { return err } provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } if err := provisioner.Provision(*h.HostOptions.SwarmOptions, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions); err != nil { return err } } return nil }
func (h *Host) Upgrade() error { machineState, err := h.Driver.GetState() if err != nil { return err } if machineState != state.Running { return errMachineMustBeRunningForUpgrade } provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return crashreport.CrashError{ Cause: err, Command: "Upgrade", Context: "provision.DetectProvisioner", DriverName: h.Driver.DriverName(), } } log.Info("Upgrading docker...") if err := provisioner.Package("docker", pkgaction.Upgrade); err != nil { return crashreport.CrashError{ Cause: err, Command: "Upgrade", Context: "provisioner.Package", DriverName: h.Driver.DriverName(), } } log.Info("Restarting docker...") return provisioner.Service("docker", serviceaction.Restart) }
func (h *Host) WaitForDocker() error { provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } return provision.WaitForDocker(provisioner, engine.DefaultPort) }
func (h *Host) Provision() error { provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } return provisioner.Provision(*h.HostOptions.SwarmOptions, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions) }
// Create is the wrapper method which covers all of the boilerplate around // actually creating, provisioning, and persisting an instance in the store. func create(store persist.Store, h *host.Host, callback func(*host.Host)) error { if err := cert.BootstrapCertificates(h.HostOptions.AuthOptions); err != nil { return fmt.Errorf("Error generating certificates: %s", err) } log.Info("Running pre-create checks...") if err := h.Driver.PreCreateCheck(); err != nil { return fmt.Errorf("Error with pre-create check: %s", err) } if err := store.Save(h); err != nil { return fmt.Errorf("Error saving host to store before attempting creation: %s", err) } log.Info("Creating machine...") if err := h.Driver.Create(); err != nil { return fmt.Errorf("Error in driver during machine creation: %s", err) } if err := store.Save(h); err != nil { return fmt.Errorf("Error saving host to store after attempting creation: %s", err) } // TODO: Not really a fan of just checking "none" here. if h.Driver.DriverName() != "none" { log.Info("Waiting for machine to be running, this may take a few minutes...") if err := mcnutils.WaitFor(drivers.MachineInState(h.Driver, state.Running)); err != nil { return fmt.Errorf("Error waiting for machine to be running: %s", err) } log.Info("Machine is running, waiting for SSH to be available...") if err := drivers.WaitForSSH(h.Driver); err != nil { return fmt.Errorf("Error waiting for SSH: %s", err) } log.Info("Detecting operating system of created instance...") provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return fmt.Errorf("Error detecting OS: %s", err) } callback(h) log.Info("Provisioning created instance...") if err := provisioner.Provision(*h.HostOptions.SwarmOptions, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions); err != nil { return fmt.Errorf("Error running provisioning: %s", err) } } log.Debug("Reticulating splines...") return nil }
func (h *Host) ConfigureAuth() error { provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } if err := provision.ConfigureAuth(provisioner, *h.HostOptions.AuthOptions); err != nil { return err } return nil }
func (h *Host) ConfigureAuth() error { provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } // TODO: This is kind of a hack (or is it? I'm not really sure until // we have more clearly defined outlook on what the responsibilities // and modularity of the provisioners should be). // // Call provision to re-provision the certs properly. return provisioner.Provision(swarm.Options{}, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions) }
func (h *Host) Upgrade() error { provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } if err := provisioner.Package("docker", pkgaction.Upgrade); err != nil { return err } if err := provisioner.Service("docker", pkgaction.Restart); err != nil { return err } return nil }
func (api *Client) performCreate(h *host.Host) error { if err := h.Driver.Create(); err != nil { return fmt.Errorf("Error in driver during machine creation: %s", err) } if err := api.Save(h); err != nil { return fmt.Errorf("Error saving host to store after attempting creation: %s", err) } // TODO: Not really a fan of just checking "none" here. if h.Driver.DriverName() != "none" { log.Info("Waiting for machine to be running, this may take a few minutes...") if err := mcnutils.WaitFor(drivers.MachineInState(h.Driver, state.Running)); err != nil { return fmt.Errorf("Error waiting for machine to be running: %s", err) } log.Info("Machine is running, waiting for SSH to be available...") if err := drivers.WaitForSSH(h.Driver); err != nil { return fmt.Errorf("Error waiting for SSH: %s", err) } log.Info("Detecting operating system of created instance...") provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return fmt.Errorf("Error detecting OS: %s", err) } log.Infof("Provisioning with %s...", provisioner.String()) if err := provisioner.Provision(*h.HostOptions.SwarmOptions, *h.HostOptions.AuthOptions, *h.HostOptions.EngineOptions); err != nil { return fmt.Errorf("Error running provisioning: %s", err) } // We should check the connection to docker here log.Info("Checking connection to Docker...") if _, _, err = check.DefaultConnChecker.Check(h, false); err != nil { return fmt.Errorf("Error checking the host: %s", err) } log.Info("Docker is up and running!") } return nil }
func (h *Host) Upgrade() error { machineState, err := h.Driver.GetState() if err != nil { return err } if machineState != state.Running { return errMachineMustBeRunningForUpgrade } provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } log.Info("Upgrading docker...") if err := provisioner.Package("docker", pkgaction.Upgrade); err != nil { return err } log.Info("Restarting docker...") return provisioner.Service("docker", serviceaction.Restart) }
func (h *Host) Upgrade() error { machineState, err := h.Driver.GetState() if err != nil { return err } if machineState != state.Running { log.Fatal(errMachineMustBeRunningForUpgrade) } provisioner, err := provision.DetectProvisioner(h.Driver) if err != nil { return err } if err := provisioner.Package("docker", pkgaction.Upgrade); err != nil { return err } if err := provisioner.Service("docker", pkgaction.Restart); err != nil { return err } return nil }
func swarmManage(h *host.Host, image string, token string) error { provisioner, err := provision.DetectProvisioner(h.Driver) dockerDir := provisioner.GetDockerOptionsDir() authOptions := setRemoteAuthOptions(provisioner) url, err := h.GetURL() if err != nil { return err } retryCount := 0 retry: exec.Command(os.Args[0], []string{ "-H", url, "--tlscacert=" + h.HostOptions.AuthOptions.CaCertPath, "--tlscert=" + h.HostOptions.AuthOptions.ClientCertPath, "--tlskey=" + h.HostOptions.AuthOptions.ClientKeyPath, "--tlsverify=true", "rm", "-f", "swarm-manager"}...).Output() cmd := exec.Command(os.Args[0], []string{ "-H", url, "--tlscacert=" + h.HostOptions.AuthOptions.CaCertPath, "--tlscert=" + h.HostOptions.AuthOptions.ClientCertPath, "--tlskey=" + h.HostOptions.AuthOptions.ClientKeyPath, "--tlsverify=true", "run", "-d", "--restart=always", "--net=bridge", "--name", "swarm-manager", "-p", "3376:3376", "-v", dockerDir + ":" + dockerDir, image, "manage", "--tlsverify", "--tlscacert=" + authOptions.CaCertRemotePath, "--tlscert=" + authOptions.ServerCertRemotePath, "--tlskey=" + authOptions.ServerKeyRemotePath, "-H", "0.0.0.0:3376", token}...) err = cmd.Run() if err == nil { fmt.Printf("Manager '%s' started successfully...\n", h.Name) return nil } if _, ok := err.(*exec.ExitError); ok { retryCount++ if retryCount <= 5 { fmt.Printf("Failed to start manager. Retry: %d\n", retryCount) goto retry } // if s, ok := exiterr.Sys().(syscall.WaitStatus); ok { // if s.ExitCode == 8 { // goto retry // } // } } return err }
func startZooKeeper(args ...string) error { p, err := machine.ReadProvision("provision.yml") if err != nil { log.Debugf("err: %s", err) return err } // extract pattern // fmt.Printf("args: %s\n",args) machineList := p.GetMachineList(args...) log.Debugf("machines: %s", machineList) if len(machineList) == 0 { return errors.New("no machine in list") } store := machine.GetDefaultStore(utils.GetBaseDir()) zooCfg := ` tickTime=2000 dataDir=/var/zookeeper/ clientPort=2181 initLimit=5 syncLimit=2 {{range $id, $ip := .}}server.{{ inc $id }}={{ $ip }}:2888:3888 {{ end }} ` addHosts := []string{} hosts := []*host.Host{} for _, name := range machineList { h, err := loadHost(store, name, utils.GetBaseDir()) if err != nil { return err } hosts = append(hosts, h) ip, err := h.Driver.GetIP() if err != nil { return err } addHosts = append(addHosts, "--add-host", name+":"+ip) } tmpl, err := template.New("zoo").Funcs(template.FuncMap{ "inc": func(i int) int { return i + 1 }, }).Parse(zooCfg) if err != nil { return err } var str bytes.Buffer err = tmpl.Execute(&str, machineList) // change ips to machine name if err != nil { return err } for _, h := range hosts { provisioner, err := provision.DetectProvisioner(h.Driver) // dockerDir := provisioner.GetDockerOptionsDir() // authOptions := setRemoteAuthOptions(provisioner) url, err := h.GetURL() if err != nil { return err } exec.Command(os.Args[0], []string{ "-H", url, "--tlscacert=" + h.HostOptions.AuthOptions.CaCertPath, "--tlscert=" + h.HostOptions.AuthOptions.ClientCertPath, "--tlskey=" + h.HostOptions.AuthOptions.ClientKeyPath, "--tlsverify=true", "rm", "-f", "swarm-discovery-service"}...).Output() // skip error checking provisioner.SSHCommand("sudo mkdir -p /opt/zookeeper/conf") // copy zooCfg transferCmdFmt := "printf '%%s' '%s' | sudo tee %s" if _, err := provisioner.SSHCommand(fmt.Sprintf(transferCmdFmt, str.String(), "/opt/zookeeper/conf/zoo.cfg")); err != nil { return err } cmd := exec.Command(os.Args[0], append([]string{ "-H", url, "--tlscacert=" + h.HostOptions.AuthOptions.CaCertPath, "--tlscert=" + h.HostOptions.AuthOptions.ClientCertPath, "--tlskey=" + h.HostOptions.AuthOptions.ClientKeyPath, "--tlsverify=true", "run", "-d", "--restart=always", "--name", "swarm-discovery-service", "-v", "/opt/zookeeper/conf:/opt/zookeeper/conf"}, append(addHosts, "-p", "2181:2181", "-p", "2888:2888", "-p", "3888:3888", "jplock/zookeeper")...)...) output, err := cmd.CombinedOutput() if err == nil { fmt.Printf("ZK '%s' started successfully...\n", h.Name) } if err != nil { fmt.Print(string(output)) return err } } return nil }
// install swarm master on the 'm' machine func (d *Driver) AddMaster(m *machine.Machine) error { cd := container.NewContainerDesc() cd.SetRestartPolicy("always", 0) p, err := provision.DetectProvisioner(m.Host.Driver) if err != nil { return err } swarmHost := d.options.String("host") u, err := url.Parse(swarmHost) if err != nil { return err } parts := strings.Split(u.Host, ":") port := parts[1] bip := parts[0] cd.AddPortBinding(bip, port, port, "tcp") dockerDir := p.GetDockerOptionsDir() b := fmt.Sprintf("%s:%s", dockerDir, dockerDir) cd.AddBind(b) cd.SetImage(d.options.String("image")) authOptions := setRemoteAuthOptions(p) cmds := []string{"manage", "--tlsverify", "--tlscacert", authOptions.CaCertRemotePath, "--tlscert", authOptions.ServerCertRemotePath, "--tlskey", authOptions.ServerKeyRemotePath, "-H", swarmHost, "--strategy", d.options.String("strategy"), } sopts := d.options.StringSlice("opt") if len(sopts) > 0 { cmds = append(cmds, sopts...) } cmds = append(cmds, d.options.String("discovery")) cd.SetCmd(cmds...) client, err := container.NewDockerClient(m) if err != nil { return err } name := "swarm-agent-master" master, err := client.GetByName(name) if err != nil { return err } id, err := checkContainerStart(name, master, cd, client) if err != nil { return err } logrus.Infof("swarm master agent is running. name:%s, id:%s", name, id) ip := m.GetCachedIp() host := fmt.Sprintf("tcp://%s:%s", ip, port) mc, err := container.NewDockerClientWithUrl(host, m) if err != nil { return err } d.masterClientChangeChan <- mc logrus.Infof("swarm master added to cluster. host:%s, name:%s", host, name) return nil }