func (p *FakeProvisioner) RemoveUnit(app provision.App, name string) error {
if err := p.getError("RemoveUnit"); err != nil {
return err
}
index := -1
appName := app.GetName()
if index := p.FindApp(app); index < 0 {
return errors.New("App is not provisioned.")
}
p.unitMut.Lock()
defer p.unitMut.Unlock()
for i, unit := range p.units[appName] {
if unit.Name == name {
index = i
break
}
}
if index == -1 {
return errors.New("Unit not found.")
}
copy(p.units[appName][index:], p.units[appName][index+1:])
p.units[appName] = p.units[appName][:len(p.units[appName])-1]
p.unitLen--
return 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
}
func deploy(app provision.App, version string, w io.Writer) (string, error) {
commands, err := deployCmds(app, version)
if err != nil {
return "", err
}
imageId := getImage(app)
actions := []*action.Action{&createContainer, &startContainer, &insertContainer}
pipeline := action.NewPipeline(actions...)
err = pipeline.Execute(app, imageId, commands)
if err != nil {
log.Errorf("error on execute deploy pipeline for app %s - %s", app.GetName(), err)
return "", err
}
c := pipeline.Result().(container)
err = c.logs(w)
if err != nil {
log.Errorf("error on get logs for container %s - %s", c.ID, err)
return "", err
}
_, err = dockerCluster().WaitContainer(c.ID)
if err != nil {
log.Errorf("Process failed for container %q: %s", c.ID, err)
return "", err
}
imageId, err = c.commit()
if err != nil {
log.Errorf("error on commit container %s - %s", c.ID, err)
return "", err
}
c.remove()
return imageId, nil
}
func (p *FakeProvisioner) RemoveUnit(app provision.App, name string) error {
if err := p.getError("RemoveUnit"); err != nil {
return err
}
index := -1
p.mut.Lock()
defer p.mut.Unlock()
pApp, ok := p.apps[app.GetName()]
if !ok {
return errNotProvisioned
}
for i, unit := range pApp.units {
if unit.Name == name {
index = i
break
}
}
if index == -1 {
return errors.New("Unit not found.")
}
copy(pApp.units[index:], pApp.units[index+1:])
pApp.units = pApp.units[:len(pApp.units)-1]
pApp.unitLen--
p.apps[app.GetName()] = pApp
return nil
}
func (p *dockerProvisioner) Destroy(app provision.App) error {
containers, _ := listAppContainers(app.GetName())
go func(c []container) {
var containersGroup sync.WaitGroup
containersGroup.Add(len(containers))
for _, c := range containers {
go func(c container) {
defer containersGroup.Done()
err := removeContainer(&c)
if err != nil {
log.Error(err.Error())
}
}(c)
}
containersGroup.Wait()
err := removeImage(assembleImageName(app.GetName()))
if err != nil {
log.Error(err.Error())
}
}(containers)
r, err := getRouter()
if err != nil {
log.Errorf("Failed to get router: %s", err)
return err
}
return r.RemoveBackend(app.GetName())
}
func needsFlatten(a provision.App) bool {
deploys := a.GetDeploys()
if deploys != 0 && deploys%20 == 0 {
return true
}
return false
}
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()
framework := app.GetFramework()
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, length+i),
AppName: name,
Type: framework,
Status: provision.StatusStarted,
Ip: fmt.Sprintf("10.10.10.%d", length+i),
Machine: int(length + i),
}
p.units[name] = append(p.units[name], unit)
}
return p.units[name][length:], nil
}
func runContainerCmd(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
}
runBin, err := config.GetString("docker:run-cmd:bin")
if err != nil {
return []string{}, err
}
runArgs, err := config.GetString("docker:run-cmd:args")
if err != nil {
return []string{}, err
}
port, err := config.GetString("docker:run-cmd:port")
if err != nil {
return []string{}, err
}
cmd := fmt.Sprintf("%s %s", runBin, runArgs)
imageName := fmt.Sprintf("%s/%s", repoNamespace, app.GetName()) // TODO (flaviamissi): should be external function
wholeCmd := []string{docker, "run", "-d", "-p", port, imageName, cmd}
return wholeCmd, nil
}
func (p *JujuProvisioner) ExecuteCommand(stdout, stderr io.Writer, app provision.App, cmd string, args ...string) error {
arguments := []string{"ssh", "-o", "StrictHostKeyChecking no", "-q"}
units := app.ProvisionUnits()
length := len(units)
for i, unit := range units {
if length > 1 {
if i > 0 {
fmt.Fprintln(stdout)
}
fmt.Fprintf(stdout, "Output from unit %q:\n\n", unit.GetName())
if status := unit.GetStatus(); status != provision.StatusStarted {
fmt.Fprintf(stdout, "Unit state is %q, it must be %q for running commands.\n",
status, provision.StatusStarted)
continue
}
}
var cmdargs []string
cmdargs = append(cmdargs, arguments...)
cmdargs = append(cmdargs, strconv.Itoa(unit.GetMachine()), cmd)
cmdargs = append(cmdargs, args...)
err := runCmd(true, stdout, stderr, cmdargs...)
fmt.Fprintln(stdout)
if err != nil {
return err
}
}
return 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 (*LXCProvisioner) ExecuteCommand(stdout, stderr io.Writer, app provision.App, cmd string, args ...string) error {
arguments := []string{"-l", "ubuntu", "-q", "-o", "StrictHostKeyChecking no"}
arguments = append(arguments, app.ProvisionedUnits()[0].GetIp())
arguments = append(arguments, cmd)
arguments = append(arguments, args...)
return executor().Execute("ssh", arguments, nil, stdout, stderr)
}
func Git(provisioner provision.Provisioner, app provision.App, w io.Writer) error {
log.Write(w, []byte("\n ---> Tsuru receiving push\n"))
log.Write(w, []byte("\n ---> Replicating the application repository across units\n"))
out, err := clone(provisioner, app)
if err != nil {
out, err = pull(provisioner, app)
}
if err != nil {
msg := fmt.Sprintf("Got error while clonning/pulling repository: %s -- \n%s", err.Error(), string(out))
log.Write(w, []byte(msg))
return errors.New(msg)
}
log.Write(w, out)
log.Write(w, []byte("\n ---> Installing dependencies\n"))
if err := provisioner.InstallDeps(app, w); err != nil {
log.Write(w, []byte(err.Error()))
return err
}
log.Write(w, []byte("\n ---> Restarting application\n"))
if err := app.Restart(w); err != nil {
log.Write(w, []byte(err.Error()))
return err
}
return log.Write(w, []byte("\n ---> Deploy done!\n\n"))
}
func usePlatformImage(app provision.App) bool {
deploys := app.GetDeploys()
if deploys != 0 && deploys%20 == 0 {
return true
}
return false
}
func (JujuProvisioner) Swap(app1, app2 provision.App) error {
r, err := Router()
if err != nil {
return err
}
return r.Swap(app1.GetName(), app2.GetName())
}
func (p *LXCProvisioner) Addr(app provision.App) (string, error) {
r, err := p.router()
if err != nil {
return "", err
}
return r.Addr(app.GetName())
}
func (p *FakeProvisioner) FindApp(app provision.App) int {
for i, a := range p.apps {
if a.GetName() == app.GetName() {
return i
}
}
return -1
}
// 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())
}
func (p *JujuProvisioner) Deploy(a provision.App, version string, w io.Writer) error {
var buf bytes.Buffer
setOption := []string{"set", a.GetName(), "app-version=" + version}
if err := runCmd(true, &buf, &buf, setOption...); err != nil {
log.Errorf("juju: Failed to set app-version. Error: %s.\nCommand output: %s", err, &buf)
}
return deploy.Git(p, a, version, w)
}
func (p *JujuProvisioner) RemoveUnits(app provision.App, n uint) error {
units := app.ProvisionUnits()
length := uint(len(units))
if length == n {
return errors.New("You can't remove all units from an app.")
} else if length < n {
return fmt.Errorf("You can't remove %d units from this app because it has only %d units.", n, length)
}
return p.removeUnits(app, units[:n]...)
}
func (p *JujuProvisioner) Addr(app provision.App) (string, error) {
if p.elbSupport() {
return p.LoadBalancer().Addr(app)
}
units := app.ProvisionUnits()
if len(units) < 1 {
return "", fmt.Errorf("App %q has no units.", app.GetName())
}
return units[0].GetIp(), nil
}
func (p *LocalProvisioner) Restart(app provision.App) error {
var buf bytes.Buffer
err := p.ExecuteCommand(&buf, &buf, app, "/var/lib/tsuru/hooks/restart")
if err != nil {
msg := fmt.Sprintf("Failed to restart the app (%s): %s", err, buf.String())
app.Log(msg, "tsuru-provisioner")
return &provision.Error{Reason: buf.String(), Err: err}
}
return nil
}
func (p *FakeProvisioner) Start(app provision.App) error {
p.mut.Lock()
defer p.mut.Unlock()
pApp, ok := p.apps[app.GetName()]
if !ok {
return errNotProvisioned
}
pApp.starts++
p.apps[app.GetName()] = pApp
return nil
}
func (p *FakeProvisioner) Restart(app provision.App) error {
if err := p.getError("Restart"); err != nil {
return err
}
p.restMut.Lock()
v := p.restarts[app.GetName()]
v++
p.restarts[app.GetName()] = v
p.restMut.Unlock()
return 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) {
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
}
func (p *FakeProvisioner) InstallDeps(app provision.App, w io.Writer) error {
if err := p.getError("InstallDeps"); err != nil {
return err
}
p.depsMut.Lock()
v := p.installDeps[app.GetName()]
v++
p.installDeps[app.GetName()] = v
p.depsMut.Unlock()
return nil
}
// Returns the number of calls to restart.
// GetCmds returns a list of commands executed in an app. If you don't specify
// the command (an empty string), it will return all commands executed in the
// given app.
func (p *FakeProvisioner) GetCmds(cmd string, app provision.App) []Cmd {
var cmds []Cmd
p.cmdMut.Lock()
for _, c := range p.cmds {
if (cmd == "" || c.Cmd == cmd) && app.GetName() == c.App.GetName() {
cmds = append(cmds, c)
}
}
p.cmdMut.Unlock()
return cmds
}
// Clone runs a git clone to clone the app repository in an ap.
func clone(p provision.Provisioner, app provision.App) ([]byte, error) {
var buf bytes.Buffer
path, err := repository.GetPath()
if err != nil {
return nil, fmt.Errorf("Tsuru is misconfigured: %s", err)
}
cmd := fmt.Sprintf("git clone %s %s --depth 1", repository.ReadOnlyURL(app.GetName()), path)
err = p.ExecuteCommand(&buf, &buf, app, cmd)
b := buf.Bytes()
log.Printf(`"git clone" output: %s`, b)
return b, err
}
func (p *FakeProvisioner) Destroy(app provision.App) error {
if err := p.getError("Destroy"); err != nil {
return err
}
if !p.Provisioned(app) {
return errNotProvisioned
}
p.mut.Lock()
defer p.mut.Unlock()
delete(p.apps, app.GetName())
return nil
}
func (p *JujuProvisioner) RemoveUnit(app provision.App, name string) error {
var unit provision.AppUnit
for _, unit = range app.ProvisionedUnits() {
if unit.GetName() == name {
break
}
}
if unit.GetName() != name {
return fmt.Errorf("App %q does not have a unit named %q.", app.GetName(), name)
}
return p.removeUnit(app, unit)
}
func (p *LXCProvisioner) Destroy(app provision.App) error {
c := container{name: app.GetName()}
go func(c container) {
log.Printf("stoping container %s", c.name)
c.stop()
log.Printf("destroying container %s", c.name)
c.destroy()
log.Printf("removing container %s from the database", c.name)
p.collection().Remove(bson.M{"name": c.name})
}(c)
return nil
}
