func (*dockerProvisioner) AddUnits(a provision.App, units uint) ([]provision.Unit, error) { if units == 0 { return nil, errors.New("Cannot add 0 units") } length, err := getContainerCountForAppName(a.GetName()) if err != nil { return nil, err } if length < 1 { return nil, errors.New("New units can only be added after the first deployment") } writer := app.LogWriter{App: a, Writer: ioutil.Discard} result := make([]provision.Unit, int(units)) container, err := getOneContainerByAppName(a.GetName()) if err != nil { return nil, err } imageId := container.Image for i := uint(0); i < units; i++ { container, err := start(a, imageId, &writer) if err != nil { return nil, err } result[i] = provision.Unit{ Name: container.ID, AppName: a.GetName(), Type: a.GetPlatform(), Ip: container.HostAddr, Status: provision.StatusBuilding, } } return result, nil }
func (p *FakeProvisioner) AddUnits(app provision.App, n uint) ([]provision.Unit, error) { if err := p.getError("AddUnits"); err != nil { return nil, err } if n == 0 { return nil, errors.New("Cannot add 0 units.") } index := p.FindApp(app) if index < 0 { return nil, errors.New("App is not provisioned.") } name := app.GetName() platform := app.GetPlatform() p.unitMut.Lock() defer p.unitMut.Unlock() length := uint(len(p.units[name])) for i := uint(0); i < n; i++ { unit := provision.Unit{ Name: fmt.Sprintf("%s/%d", name, p.unitLen), AppName: name, Type: platform, Status: provision.StatusStarted, InstanceId: fmt.Sprintf("i-08%d", length+i), Ip: fmt.Sprintf("10.10.10.%d", length+i), Machine: int(length + i), } p.units[name] = append(p.units[name], unit) p.unitLen++ } result := make([]provision.Unit, int(n)) copy(result, p.units[name][length:]) return result, nil }
// newContainer creates a new container in Docker and stores it in the database. func newContainer(app provision.App, imageId string, cmds []string) (container, error) { cont := container{ AppName: app.GetName(), Type: app.GetPlatform(), } port, err := getPort() if err != nil { log.Printf("error on getting port for container %s - %s", cont.AppName, port) return container{}, err } config := docker.Config{ Image: imageId, Cmd: cmds, PortSpecs: []string{port}, AttachStdin: false, AttachStdout: false, AttachStderr: false, } hostID, c, err := dockerCluster().CreateContainer(&config) if err != nil { log.Printf("error on creating container in docker %s - %s", cont.AppName, err.Error()) return container{}, err } cont.ID = c.ID cont.Port = port cont.HostAddr = getHostAddr(hostID) return cont, nil }
func (p *FakeProvisioner) Provision(app provision.App) error { if err := p.getError("Provision"); err != nil { return err } index := p.FindApp(app) if index > -1 { return &provision.Error{Reason: "App already provisioned."} } p.apps = append(p.apps, app) p.unitMut.Lock() p.units[app.GetName()] = []provision.Unit{ { Name: app.GetName() + "/0", AppName: app.GetName(), Type: app.GetPlatform(), Status: provision.StatusStarted, InstanceId: "i-080", Ip: "10.10.10.1", Machine: 1, }, } p.unitLen++ p.unitMut.Unlock() return nil }
func (p *FakeProvisioner) Provision(app provision.App) error { if err := p.getError("Provision"); err != nil { return err } if p.Provisioned(app) { return &provision.Error{Reason: "App already provisioned."} } p.mut.Lock() defer p.mut.Unlock() p.apps[app.GetName()] = provisionedApp{ app: app, unitLen: 1, units: []provision.Unit{ { Name: app.GetName() + "/0", AppName: app.GetName(), Type: app.GetPlatform(), Status: provision.StatusStarted, InstanceId: "i-080", Ip: "10.10.10.1", Machine: 1, }, }, } return nil }
func (*dockerProvisioner) AddUnits(a provision.App, units uint) ([]provision.Unit, error) { if units == 0 { return nil, errors.New("Cannot add 0 units") } containers, err := listAppContainers(a.GetName()) if err != nil { return nil, err } if len(containers) < 1 { return nil, errors.New("New units can only be added after the first deployment") } writer := app.LogWriter{App: a, Writer: ioutil.Discard} result := make([]provision.Unit, int(units)) imageId := getImage(a) for i := uint(0); i < units; i++ { container, err := start(a, imageId, &writer) if err != nil { return nil, err } result[i] = provision.Unit{ Name: container.ID, AppName: a.GetName(), Type: a.GetPlatform(), Ip: container.IP, Status: provision.StatusInstalling, } } return result, nil }
func (p *FakeProvisioner) AddUnits(app provision.App, n uint) ([]provision.Unit, error) { if err := p.getError("AddUnits"); err != nil { return nil, err } if n == 0 { return nil, errors.New("Cannot add 0 units.") } p.mut.Lock() defer p.mut.Unlock() pApp, ok := p.apps[app.GetName()] if !ok { return nil, errNotProvisioned } name := app.GetName() platform := app.GetPlatform() length := uint(len(pApp.units)) for i := uint(0); i < n; i++ { unit := provision.Unit{ Name: fmt.Sprintf("%s/%d", name, pApp.unitLen), AppName: name, Type: platform, Status: provision.StatusStarted, InstanceId: fmt.Sprintf("i-08%d", length+i), Ip: fmt.Sprintf("10.10.10.%d", length+i), Machine: int(length + i), } pApp.units = append(pApp.units, unit) pApp.unitLen++ } result := make([]provision.Unit, int(n)) copy(result, pApp.units[length:]) p.apps[app.GetName()] = pApp return result, nil }
// getImage returns the image name or id from an app. func getImage(app provision.App) string { var c container collection().Find(bson.M{"appname": app.GetName()}).One(&c) if c.Image != "" { return c.Image } return assembleImageName(app.GetPlatform()) }
// newContainer creates a new container in Docker and stores it in the database. func newContainer(app provision.App, imageId string, cmds []string) (container, error) { contName := containerName() cont := container{ AppName: app.GetName(), Type: app.GetPlatform(), Name: contName, Status: "created", } coll := collection() defer coll.Close() if err := coll.Insert(cont); err != nil { log.Errorf("error on inserting container into database %s - %s", cont.Name, err) return container{}, err } port, err := getPort() if err != nil { log.Errorf("error on getting port for container %s - %s", cont.AppName, port) return container{}, err } user, _ := config.GetString("docker:ssh:user") exposedPorts := make(map[docker.Port]struct{}, 1) p := docker.Port(fmt.Sprintf("%s/tcp", port)) exposedPorts[p] = struct{}{} config := docker.Config{ Image: imageId, Cmd: cmds, User: user, ExposedPorts: exposedPorts, AttachStdin: false, AttachStdout: false, AttachStderr: false, } opts := dclient.CreateContainerOptions{Name: contName} hostID, c, err := dockerCluster().CreateContainer(opts, &config) if err == dclient.ErrNoSuchImage { var buf bytes.Buffer pullOpts := dclient.PullImageOptions{Repository: imageId} dockerCluster().PullImage(pullOpts, &buf) hostID, c, err = dockerCluster().CreateContainer(opts, &config) } if err != nil { log.Errorf("error on creating container in docker %s - %s", cont.AppName, err) return container{}, err } cont.ID = c.ID cont.Port = port cont.HostAddr = getHostAddr(hostID) err = coll.Update(bson.M{"name": cont.Name}, cont) if err != nil { log.Errorf("error on updating container into database %s - %s", cont.ID, err) return container{}, err } return cont, nil }
// getImage returns the image name or id from an app. func getImage(app provision.App) string { var c container collection().Find(bson.M{"appname": app.GetName()}).One(&c) if c.Image != "" { return c.Image } repoNamespace, err := config.GetString("docker:repository-namespace") if err != nil { return "" } return fmt.Sprintf("%s/%s", repoNamespace, app.GetPlatform()) }
// newContainer creates a new container in Docker and stores it in the database. // // TODO (flaviamissi): make it atomic func newContainer(app provision.App) (*container, error) { appName := app.GetName() c := container{ AppName: appName, Type: app.GetPlatform(), } err := c.create(app) if err != nil { log.Printf("Error creating container for the app %q: %s", appName, err) return nil, err } return &c, nil }
func (p *JujuProvisioner) Provision(app provision.App) error { var buf bytes.Buffer charms, err := config.GetString("juju:charms-path") if err != nil { return errors.New(`Setting "juju:charms-path" is not defined.`) } args := []string{ "deploy", "--repository", charms, "local:" + app.GetPlatform(), app.GetName(), } err = runCmd(false, &buf, &buf, args...) out := buf.String() if err != nil { app.Log("Failed to create machine: "+out, "tsuru") return cmdError(out, err, args) } setOption := []string{ "set", app.GetName(), "app-repo=" + repository.ReadOnlyURL(app.GetName()), } runCmd(true, &buf, &buf, setOption...) if p.elbSupport() { router, err := Router() if err != nil { return err } if err = router.AddBackend(app.GetName()); err != nil { return err } p.enqueueUnits(app.GetName()) } return nil }
// getImage returns the image name or id from an app. func getImage(app provision.App) string { var c container coll := collection() defer coll.Close() coll.Find(bson.M{"appname": app.GetName()}).One(&c) if c.Image == "" { return assembleImageName(app.GetPlatform()) } if usePlatformImage(app) { err := removeImage(c.Image) if err != nil { log.Error(err.Error()) } return assembleImageName(app.GetPlatform()) } return c.Image }
// DeployCmd combines settings and application attributes needed in // order to make a deploy command func deployContainerCmd(app provision.App) ([]string, error) { docker, err := config.GetString("docker:binary") if err != nil { return []string{}, err } repoNamespace, err := config.GetString("docker:repository-namespace") if err != nil { return []string{}, err } cmd, err := config.GetString("docker:deploy-cmd") if err != nil { return []string{}, err } cmd = fmt.Sprintf("%s %s", cmd, repository.GetReadOnlyUrl(app.GetName())) imageName := fmt.Sprintf("%s/%s", repoNamespace, app.GetPlatform()) // TODO (flaviamissi): should use same algorithm as image.repositoryName wholeCmd := []string{docker, "run", "-d", imageName, cmd} return wholeCmd, nil }
func commandToRun(app provision.App) ([]string, error) { docker, err := config.GetString("docker:binary") if err != nil { return nil, err } repoNamespace, err := config.GetString("docker:repository-namespace") if err != nil { return nil, err } port, err := config.GetString("docker:run-cmd:port") if err != nil { return nil, err } commands, err := getSSHCommands() if err != nil { return nil, err } imageName := fmt.Sprintf("%s/%s", repoNamespace, app.GetPlatform()) // TODO (flaviamissi): should use same algorithm as image.repositoryName containerCmd := strings.Join(commands, " && ") wholeCmd := []string{docker, "run", "-d", "-t", "-p", port, imageName, "/bin/bash", "-c", containerCmd} return wholeCmd, nil }
// newContainer creates a new container in docker and stores it on database. // // Receives the application to which the container is going to be generated // and the function to assemble the command that the container will execute on // startup. // TODO (flaviamissi): make it atomic func newContainer(app provision.App, f func(provision.App) ([]string, error)) (*container, error) { appName := app.GetName() c := &container{name: appName} id, err := c.create(app, f) if err != nil { log.Printf("Error creating container %s", appName) log.Printf("Error was: %s", err.Error()) return c, err } c.id = id u := provision.Unit{ Name: app.GetName(), AppName: app.GetName(), Type: app.GetPlatform(), Machine: 0, InstanceId: app.GetName(), Status: provision.StatusCreating, Ip: "", } if err := collection().Insert(u); err != nil { log.Print(err) return c, err } // adding a route to a container that only installs the dependencies // (deployContainerCmd) is a waste of processing, since this container is // not going to be used, we should improve it r, err := getRouter() if err != nil { return c, err } ip, err := c.ip() if err != nil { return c, err } return c, r.AddRoute(app.GetName(), ip) }
func (p *LXCProvisioner) Provision(app provision.App) error { go func(p *LXCProvisioner, app provision.App) { c := container{name: app.GetName()} log.Printf("creating container %s", c.name) u := provision.Unit{ Name: app.GetName(), AppName: app.GetName(), Type: app.GetPlatform(), Machine: 0, InstanceId: app.GetName(), Status: provision.StatusCreating, Ip: "", } log.Printf("inserting container unit %s in the database", app.GetName()) err := p.collection().Insert(u) if err != nil { log.Print(err) } err = c.create() if err != nil { log.Printf("error on create container %s", app.GetName()) log.Print(err) } err = c.start() if err != nil { log.Printf("error on start container %s", app.GetName()) log.Print(err) } u.Ip = c.IP() u.Status = provision.StatusInstalling err = p.collection().Update(bson.M{"name": u.Name}, u) if err != nil { log.Print(err) } err = c.waitForNetwork() if err != nil { log.Print(err) } err = p.setup(c.IP(), app.GetPlatform()) if err != nil { log.Printf("error on setup container %s", app.GetName()) log.Print(err) } err = p.install(c.IP()) if err != nil { log.Printf("error on install container %s", app.GetName()) log.Print(err) } err = p.start(c.IP()) if err != nil { log.Printf("error on start app for container %s", app.GetName()) log.Print(err) } err = p.start(c.IP()) r, err := p.router() if err != nil { log.Print(err) return } err = r.AddBackend(app.GetName()) if err != nil { log.Printf("error on add backend for %s", app.GetName()) log.Print(err) return } err = r.AddRoute(app.GetName(), c.IP()) if err != nil { log.Printf("error on add route for %s with ip %s", app.GetName(), c.IP()) log.Print(err) } u.Status = provision.StatusStarted err = p.collection().Update(bson.M{"name": u.Name}, u) if err != nil { log.Print(err) } }(p, app) return nil }