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 *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 (*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.")
}
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
}
// 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) 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 (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
}
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 *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 *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 (p *LXCProvisioner) Addr(app provision.App) (string, error) {
r, err := p.router()
if err != nil {
return "", err
}
return r.Addr(app.GetName())
}
func (p *dockerProvisioner) Deploy(a provision.App, w io.Writer) error {
var deploy = func() error {
c, err := newContainer(a)
if err != nil {
return err
}
err = c.deploy(w)
if err != nil {
c.remove()
}
return err
}
if containers, err := listAppContainers(a.GetName()); err == nil && len(containers) > 0 {
for _, c := range containers {
err = deploy()
if err != nil {
return err
}
a.RemoveUnit(c.Id)
}
} else if err := deploy(); err != nil {
return err
}
a.Restart(w)
app.Enqueue(queue.Message{
Action: app.RegenerateApprcAndStart,
Args: []string{a.GetName()},
})
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
}
// 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 *FakeProvisioner) FindApp(app provision.App) int {
for i, a := range p.apps {
if a.GetName() == app.GetName() {
return i
}
}
return -1
}
// 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) 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) 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
}
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
}
// 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
}
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
}
// 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())
}
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
}
// 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 *JujuProvisioner) RemoveUnit(app provision.App, name string) error {
var unit provision.AppUnit
for _, unit = range app.ProvisionUnits() {
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.removeUnits(app, unit)
}
// deployCmds returns the commands that is used when provisioner
// deploy an unit.
func deployCmds(app provision.App, version string) ([]string, error) {
deployCmd, err := config.GetString("docker:deploy-cmd")
if err != nil {
return nil, err
}
appRepo := repository.ReadOnlyURL(app.GetName())
user, err := config.GetString("docker:ssh:user")
if err != nil {
return nil, err
}
cmds := []string{"sudo", "-u", user, deployCmd, appRepo, version}
return cmds, nil
}
// deployCmds returns the commands that is used when provisioner
// deploy an unit.
func deployCmds(app provision.App, version string) ([]string, error) {
deployCmd, err := config.GetString("docker:deploy-cmd")
if err != nil {
return nil, err
}
appRepo := repository.ReadOnlyURL(app.GetName())
var envs string
for _, env := range app.Envs() {
envs += fmt.Sprintf("%s='%s' ", env.Name, env.Value)
}
cmds := []string{deployCmd, appRepo, version, envs}
return cmds, nil
}
