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
}
