func (s *S) TestSetRouterHealthcheckBackward(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
imageName := "tsuru/img1"
customData := map[string]interface{}{
"healthcheck": map[string]interface{}{
"path": "/x/y",
"status": http.StatusCreated,
"match": "ignored",
"use_in_router": true,
},
}
err := image.SaveImageCustomData(imageName, customData)
c.Assert(err, check.IsNil)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
args := changeUnitsPipelineArgs{
app: app,
provisioner: s.p,
imageId: imageName,
}
cont1 := container.Container{ID: "ble-1", AppName: app.GetName(), ProcessName: "web", HostAddr: "127.0.0.1", HostPort: "1234"}
context := action.FWContext{Previous: []container.Container{cont1}, Params: []interface{}{args}}
_, err = setRouterHealthcheck.Forward(context)
c.Assert(err, check.IsNil)
hcData := routertest.FakeRouter.GetHealthcheck(app.GetName())
c.Assert(hcData, check.DeepEquals, router.HealthcheckData{
Path: "/x/y",
Status: http.StatusCreated,
})
bwcontext := action.BWContext{Params: []interface{}{args}}
setRouterHealthcheck.Backward(bwcontext)
hcData = routertest.FakeRouter.GetHealthcheck(app.GetName())
c.Assert(hcData, check.DeepEquals, router.HealthcheckData{Path: "/"})
}
func (s *S) TestContainerCreate(c *gocheck.C) {
app := testing.NewFakeApp("app-name", "brainfuck", 1)
app.Memory = 15
rtesting.FakeRouter.AddBackend(app.GetName())
defer rtesting.FakeRouter.RemoveBackend(app.GetName())
dockerCluster().PullImage(
docker.PullImageOptions{Repository: "tsuru/brainfuck"},
docker.AuthConfiguration{},
)
cont := container{Name: "myName", AppName: app.GetName(), Type: app.GetPlatform(), Status: "created"}
err := cont.create(app, getImage(app), []string{"docker", "run"})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(&cont)
c.Assert(cont.ID, gocheck.Not(gocheck.Equals), "")
c.Assert(cont, gocheck.FitsTypeOf, container{})
c.Assert(cont.AppName, gocheck.Equals, app.GetName())
c.Assert(cont.Type, gocheck.Equals, app.GetPlatform())
u, _ := url.Parse(s.server.URL())
host, _, _ := net.SplitHostPort(u.Host)
c.Assert(cont.HostAddr, gocheck.Equals, host)
user, err := config.GetString("docker:ssh:user")
c.Assert(err, gocheck.IsNil)
c.Assert(cont.User, gocheck.Equals, user)
dcli, _ := docker.NewClient(s.server.URL())
container, err := dcli.InspectContainer(cont.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(container.Path, gocheck.Equals, "docker")
c.Assert(container.Args, gocheck.DeepEquals, []string{"run"})
c.Assert(container.Config.User, gocheck.Equals, user)
c.Assert(container.Config.Memory, gocheck.Equals, int64(app.Memory*1024*1024))
}
func (p *dockerProvisioner) FilterAppsByUnitStatus(apps []provision.App, status []string) ([]provision.App, error) {
if apps == nil {
return nil, fmt.Errorf("apps must be provided to FilterAppsByUnitStatus")
}
if status == nil {
return make([]provision.App, 0), nil
}
appNames := make([]string, len(apps))
for i, app := range apps {
appNames[i] = app.GetName()
}
containers, err := p.listContainersByAppAndStatus(appNames, status)
if err != nil {
return nil, err
}
result := make([]provision.App, 0)
for _, app := range apps {
for _, c := range containers {
if app.GetName() == c.AppName {
result = append(result, app)
break
}
}
}
return result, nil
}
func (s *S) TestProvisionerAddUnitsWithErrorDoesntLeaveLostUnits(c *gocheck.C) {
callCount := 0
s.server.CustomHandler("/containers/create", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
callCount++
if callCount == 2 {
w.WriteHeader(http.StatusInternalServerError)
return
}
s.server.DefaultHandler().ServeHTTP(w, r)
}))
defer s.server.CustomHandler("/containers/create", s.server.DefaultHandler())
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
var p dockerProvisioner
app := testing.NewFakeApp("myapp", "python", 0)
p.Provision(app)
defer p.Destroy(app)
coll := collection()
defer coll.Close()
coll.Insert(container{ID: "c-89320", AppName: app.GetName(), Version: "a345fe", Image: "tsuru/python"})
defer coll.RemoveId(bson.M{"id": "c-89320"})
_, err = p.AddUnits(app, 3)
c.Assert(err, gocheck.NotNil)
count, err := coll.Find(bson.M{"appname": app.GetName()}).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(count, gocheck.Equals, 1)
}
func (s *S) TestProvisionAddUnitsToHostForwardWithoutHost(c *check.C) {
p, err := s.startMultipleServersCluster()
c.Assert(err, check.IsNil)
app := provisiontest.NewFakeApp("myapp-2", "python", 0)
defer p.Destroy(app)
p.Provision(app)
coll := p.Collection()
defer coll.Close()
imageId, err := appNewImageName(app.GetName())
c.Assert(err, check.IsNil)
err = s.newFakeImage(p, imageId, nil)
c.Assert(err, check.IsNil)
args := changeUnitsPipelineArgs{
app: app,
toAdd: map[string]*containersToAdd{"web": {Quantity: 3}},
imageId: imageId,
provisioner: p,
}
context := action.FWContext{Params: []interface{}{args}}
result, err := provisionAddUnitsToHost.Forward(context)
c.Assert(err, check.IsNil)
containers := result.([]container.Container)
c.Assert(containers, check.HasLen, 3)
addrs := []string{containers[0].HostAddr, containers[1].HostAddr, containers[2].HostAddr}
sort.Strings(addrs)
isValid := reflect.DeepEqual(addrs, []string{"127.0.0.1", "localhost", "localhost"}) ||
reflect.DeepEqual(addrs, []string{"127.0.0.1", "127.0.0.1", "localhost"})
if !isValid {
clusterNodes, _ := p.Cluster().UnfilteredNodes()
c.Fatalf("Expected multiple hosts, got: %#v\nAvailable nodes: %#v", containers, clusterNodes)
}
count, err := coll.Find(bson.M{"appname": app.GetName()}).Count()
c.Assert(err, check.IsNil)
c.Assert(count, check.Equals, 3)
}
func (s *S) TestContainerCreateDoesNotAlocatesPortForDeploy(c *check.C) {
s.server.CustomHandler("/images/.*/json", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
response := docker.Image{
Config: &docker.Config{
ExposedPorts: map[docker.Port]struct{}{},
},
}
j, _ := json.Marshal(response)
w.Write(j)
}))
app := provisiontest.NewFakeApp("app-name", "brainfuck", 1)
app.Memory = 15
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
img := "tsuru/brainfuck:latest"
s.p.Cluster().PullImage(docker.PullImageOptions{Repository: img}, docker.AuthConfiguration{})
cont := Container{
Name: "myName",
AppName: app.GetName(),
Type: app.GetPlatform(),
Status: "created",
}
err := cont.Create(&CreateArgs{
Deploy: true,
App: app,
ImageID: img,
Commands: []string{"docker", "run"},
Provisioner: s.p,
})
c.Assert(err, check.IsNil)
defer s.removeTestContainer(&cont)
info, err := cont.NetworkInfo(s.p)
c.Assert(err, check.IsNil)
c.Assert(info.HTTPHostPort, check.Equals, "")
}
func (s *S) TestContainerCreateDoesNotAlocatesPortForDeploy(c *check.C) {
app := provisiontest.NewFakeApp("app-name", "brainfuck", 1)
app.Memory = 15
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
img := "tsuru/brainfuck:latest"
s.p.Cluster().PullImage(docker.PullImageOptions{Repository: img}, docker.AuthConfiguration{})
cont := Container{
Name: "myName",
AppName: app.GetName(),
Type: app.GetPlatform(),
Status: "created",
}
err := cont.Create(&CreateArgs{
Deploy: true,
App: app,
ImageID: img,
Commands: []string{"docker", "run"},
Provisioner: s.p,
})
c.Assert(err, check.IsNil)
defer s.removeTestContainer(&cont)
info, err := cont.NetworkInfo(s.p)
c.Assert(err, check.IsNil)
c.Assert(info.HTTPHostPort, check.Equals, "")
}
func (s *S) TestContainerCreateUndefinedUser(c *check.C) {
oldUser, _ := config.Get("docker:user")
defer config.Set("docker:user", oldUser)
config.Unset("docker:user")
img := "tsuru/python:latest"
s.p.Cluster().PullImage(docker.PullImageOptions{Repository: img}, docker.AuthConfiguration{})
app := provisiontest.NewFakeApp("app-name", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
cont := Container{
Name: "myName",
AppName: app.GetName(),
Type: app.GetPlatform(),
Status: "created",
}
err := cont.Create(&CreateArgs{
App: app,
ImageID: img,
Commands: []string{"docker", "run"},
Provisioner: s.p,
})
c.Assert(err, check.IsNil)
defer s.removeTestContainer(&cont)
dcli, _ := docker.NewClient(s.server.URL())
container, err := dcli.InspectContainer(cont.ID)
c.Assert(err, check.IsNil)
c.Assert(container.Config.User, check.Equals, "")
}
func (s *S) TestProvisionAddUnitsToHostForward(c *check.C) {
p, err := s.startMultipleServersCluster()
c.Assert(err, check.IsNil)
app := provisiontest.NewFakeApp("myapp-2", "python", 0)
defer p.Destroy(app)
p.Provision(app)
coll := p.Collection()
defer coll.Close()
coll.Insert(container.Container{ID: "container-id", AppName: app.GetName(), Version: "container-version", Image: "tsuru/python"})
defer coll.RemoveAll(bson.M{"appname": app.GetName()})
imageId, err := appNewImageName(app.GetName())
c.Assert(err, check.IsNil)
err = s.newFakeImage(p, imageId, nil)
c.Assert(err, check.IsNil)
args := changeUnitsPipelineArgs{
app: app,
toHost: "localhost",
toAdd: map[string]*containersToAdd{"web": {Quantity: 2}},
imageId: imageId,
provisioner: p,
}
context := action.FWContext{Params: []interface{}{args}}
result, err := provisionAddUnitsToHost.Forward(context)
c.Assert(err, check.IsNil)
containers := result.([]container.Container)
c.Assert(containers, check.HasLen, 2)
c.Assert(containers[0].HostAddr, check.Equals, "localhost")
c.Assert(containers[1].HostAddr, check.Equals, "localhost")
count, err := coll.Find(bson.M{"appname": app.GetName()}).Count()
c.Assert(err, check.IsNil)
c.Assert(count, check.Equals, 3)
}
func (s *S) TestInsertEmptyContainerInDBForward(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
args := runContainerActionsArgs{
app: app,
imageID: "image-id",
buildingImage: "next-image",
provisioner: s.p,
}
context := action.FWContext{Params: []interface{}{args}}
r, err := insertEmptyContainerInDB.Forward(context)
c.Assert(err, check.IsNil)
cont := r.(container.Container)
c.Assert(cont, check.FitsTypeOf, container.Container{})
c.Assert(cont.AppName, check.Equals, app.GetName())
c.Assert(cont.Type, check.Equals, app.GetPlatform())
c.Assert(cont.Name, check.Not(check.Equals), "")
c.Assert(strings.HasPrefix(cont.Name, app.GetName()+"-"), check.Equals, true)
c.Assert(cont.Name, check.HasLen, 26)
c.Assert(cont.Status, check.Equals, "created")
c.Assert(cont.Image, check.Equals, "image-id")
c.Assert(cont.BuildingImage, check.Equals, "next-image")
coll := s.p.Collection()
defer coll.Close()
defer coll.Remove(bson.M{"name": cont.Name})
var retrieved container.Container
err = coll.Find(bson.M{"name": cont.Name}).One(&retrieved)
c.Assert(err, check.IsNil)
c.Assert(retrieved.Name, check.Equals, cont.Name)
}
func (s *S) TestContainerCreateSecurityOptions(c *check.C) {
config.Set("docker:security-opts", []string{"label:type:svirt_apache", "ptrace peer=@unsecure"})
defer config.Unset("docker:security-opts")
app := provisiontest.NewFakeApp("app-name", "brainfuck", 1)
app.Memory = 15
app.Swap = 15
app.CpuShare = 50
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
img := "tsuru/brainfuck:latest"
s.p.Cluster().PullImage(docker.PullImageOptions{Repository: img}, docker.AuthConfiguration{})
cont := Container{
Name: "myName",
AppName: app.GetName(),
Type: app.GetPlatform(),
Status: "created",
}
err := cont.Create(&CreateArgs{
App: app,
ImageID: img,
Commands: []string{"docker", "run"},
Provisioner: s.p,
})
c.Assert(err, check.IsNil)
defer s.removeTestContainer(&cont)
dcli, _ := docker.NewClient(s.server.URL())
container, err := dcli.InspectContainer(cont.ID)
c.Assert(err, check.IsNil)
c.Assert(container.Config.SecurityOpts, check.DeepEquals, []string{"label:type:svirt_apache", "ptrace peer=@unsecure"})
}
func (s *S) TestAddNewRouteBackward(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
cont1 := container.Container{ID: "ble-1", AppName: app.GetName(), ProcessName: "web", HostAddr: "127.0.0.1", HostPort: "1234"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "web", HostAddr: "127.0.0.2", HostPort: "4321"}
cont3 := container.Container{ID: "ble-3", AppName: app.GetName(), ProcessName: "worker", HostAddr: "127.0.0.3", HostPort: "8080"}
defer cont1.Remove(s.p)
defer cont2.Remove(s.p)
defer cont3.Remove(s.p)
err := routertest.FakeRouter.AddRoute(app.GetName(), cont1.Address())
c.Assert(err, check.IsNil)
err = routertest.FakeRouter.AddRoute(app.GetName(), cont2.Address())
c.Assert(err, check.IsNil)
args := changeUnitsPipelineArgs{
app: app,
provisioner: s.p,
}
cont1.Routable = true
cont2.Routable = true
context := action.BWContext{FWResult: []container.Container{cont1, cont2, cont3}, Params: []interface{}{args}}
addNewRoutes.Backward(context)
hasRoute := routertest.FakeRouter.HasRoute(app.GetName(), cont1.Address().String())
c.Assert(hasRoute, check.Equals, false)
hasRoute = routertest.FakeRouter.HasRoute(app.GetName(), cont2.Address().String())
c.Assert(hasRoute, check.Equals, false)
hasRoute = routertest.FakeRouter.HasRoute(app.GetName(), cont3.Address().String())
c.Assert(hasRoute, check.Equals, false)
}
func (s *S) TestArchiveDeployCanceledEvent(c *check.C) {
err := s.newFakeImage(s.p, "tsuru/python:latest", nil)
c.Assert(err, check.IsNil)
app := provisiontest.NewFakeApp("myapp", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
evt, err := event.New(&event.Opts{
Target: event.Target{Type: "app", Value: "myapp"},
Kind: permission.PermAppDeploy,
Owner: s.token,
Cancelable: true,
Allowed: event.Allowed(permission.PermApp),
AllowedCancel: event.Allowed(permission.PermApp),
})
c.Assert(err, check.IsNil)
done := make(chan bool)
go func() {
defer close(done)
img, depErr := s.p.archiveDeploy(app, image.GetBuildImage(app), "https://s3.amazonaws.com/wat/archive.tar.gz", evt)
c.Assert(depErr, check.ErrorMatches, "deploy canceled by user action")
c.Assert(img, check.Equals, "")
}()
time.Sleep(100 * time.Millisecond)
err = evt.TryCancel("because yes", "*****@*****.**")
c.Assert(err, check.IsNil)
<-done
}
func (s *S) TestProvisionerExecuteCommand(c *gocheck.C) {
file, err := ioutil.TempFile("", "tsuru-docker-tests-cmd")
c.Assert(err, gocheck.IsNil)
defer os.Remove(file.Name())
defer file.Close()
file.Write([]byte("ashes in the flesh\n"))
server := newMockSSHServer(c, 5e9)
defer server.Shutdown()
app := testing.NewFakeApp("starbreaker", "python", 1)
container1, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container1)
container1.SSHHostPort = server.port
container1.HostAddr = "localhost"
container1.PrivateKey = string(fakeServerPrivateKey)
container1.User = sshUsername()
coll := collection()
defer coll.Close()
coll.Update(bson.M{"id": container1.ID}, container1)
container2, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container2)
container2.SSHHostPort = server.port
container2.HostAddr = "localhost"
container2.PrivateKey = string(fakeServerPrivateKey)
container2.User = sshUsername()
coll.Update(bson.M{"id": container2.ID}, container2)
var stdout, stderr bytes.Buffer
var p dockerProvisioner
err = p.ExecuteCommand(&stdout, &stderr, app, "cat", file.Name())
c.Assert(err, gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, "ashes in the flesh\nashes in the flesh\n")
}
func (s *S) TestProvisionerStopSkipAlreadyStoppedContainers(c *gocheck.C) {
dcli, _ := docker.NewClient(s.server.URL())
app := testing.NewFakeApp("almah", "static", 2)
p := dockerProvisioner{}
container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container)
err = dcli.StartContainer(container.ID, nil)
c.Assert(err, gocheck.IsNil)
dockerContainer, err := dcli.InspectContainer(container.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer.State.Running, gocheck.Equals, true)
container2, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container2)
err = dcli.StartContainer(container2.ID, nil)
c.Assert(err, gocheck.IsNil)
err = dcli.StopContainer(container2.ID, 1)
c.Assert(err, gocheck.IsNil)
container2.setStatus(provision.StatusStopped.String())
dockerContainer2, err := dcli.InspectContainer(container2.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer2.State.Running, gocheck.Equals, false)
err = p.Stop(app)
c.Assert(err, gocheck.IsNil)
dockerContainer, err = dcli.InspectContainer(container.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer.State.Running, gocheck.Equals, false)
dockerContainer2, err = dcli.InspectContainer(container2.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer2.State.Running, gocheck.Equals, false)
}
func (s *S) TestContainerCreate(c *check.C) {
config.Set("host", "my.cool.tsuru.addr:8080")
defer config.Unset("host")
app := provisiontest.NewFakeApp("app-name", "brainfuck", 1)
app.Memory = 15
app.Swap = 15
app.CpuShare = 50
app.SetEnv(bind.EnvVar{Name: "A", Value: "myenva"})
app.SetEnv(bind.EnvVar{Name: "ABCD", Value: "other env"})
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
img := "tsuru/brainfuck:latest"
s.p.Cluster().PullImage(docker.PullImageOptions{Repository: img}, docker.AuthConfiguration{})
cont := Container{
Name: "myName",
AppName: app.GetName(),
Type: app.GetPlatform(),
Status: "created",
ProcessName: "myprocess1",
}
err := cont.Create(&CreateArgs{
App: app,
ImageID: img,
Commands: []string{"docker", "run"},
Provisioner: s.p,
})
c.Assert(err, check.IsNil)
defer s.removeTestContainer(&cont)
c.Assert(cont.ID, check.Not(check.Equals), "")
c.Assert(cont.AppName, check.Equals, app.GetName())
c.Assert(cont.Type, check.Equals, app.GetPlatform())
u, _ := url.Parse(s.server.URL())
host, _, _ := net.SplitHostPort(u.Host)
c.Assert(cont.HostAddr, check.Equals, host)
user, err := config.GetString("docker:user")
c.Assert(err, check.IsNil)
c.Assert(cont.User, check.Equals, user)
dcli, _ := docker.NewClient(s.server.URL())
container, err := dcli.InspectContainer(cont.ID)
c.Assert(err, check.IsNil)
c.Assert(container.Path, check.Equals, "docker")
c.Assert(container.Args, check.DeepEquals, []string{"run"})
c.Assert(container.Config.User, check.Equals, user)
c.Assert(container.Config.Memory, check.Equals, app.Memory)
c.Assert(container.Config.MemorySwap, check.Equals, app.Memory+app.Swap)
c.Assert(container.Config.CPUShares, check.Equals, int64(app.CpuShare))
sort.Strings(container.Config.Env)
c.Assert(container.Config.Env, check.DeepEquals, []string{
"A=myenva",
"ABCD=other env",
"PORT=8888",
"TSURU_HOST=my.cool.tsuru.addr:8080",
"TSURU_PROCESSNAME=myprocess1",
"port=8888",
})
}
func (s *S) TestProvision(c *check.C) {
app := NewFakeApp("kid-gloves", "rush", 1)
p := NewFakeProvisioner()
err := p.Provision(app)
c.Assert(err, check.IsNil)
pApp := p.apps[app.GetName()]
c.Assert(pApp.app, check.DeepEquals, app)
c.Assert(pApp.units, check.HasLen, 0)
c.Assert(routertest.FakeRouter.HasBackend(app.GetName()), check.Equals, true)
}
func (s *S) TestRemoveOldRoutesForward(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
cont1 := container.Container{ID: "ble-1", AppName: app.GetName(), ProcessName: "web", HostAddr: "127.0.0.1", HostPort: "1234"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "web", HostAddr: "127.0.0.2", HostPort: "4321"}
cont3 := container.Container{ID: "ble-3", AppName: app.GetName(), ProcessName: "worker", HostAddr: "127.0.0.3", HostPort: "8080"}
defer cont1.Remove(s.p)
defer cont2.Remove(s.p)
defer cont3.Remove(s.p)
err := routertest.FakeRouter.AddRoute(app.GetName(), cont1.Address())
c.Assert(err, check.IsNil)
err = routertest.FakeRouter.AddRoute(app.GetName(), cont2.Address())
c.Assert(err, check.IsNil)
args := changeUnitsPipelineArgs{
app: app,
toRemove: []container.Container{cont1, cont2, cont3},
provisioner: s.p,
}
context := action.FWContext{Previous: []container.Container{}, Params: []interface{}{args}}
r, err := removeOldRoutes.Forward(context)
c.Assert(err, check.IsNil)
hasRoute := routertest.FakeRouter.HasRoute(app.GetName(), cont1.Address().String())
c.Assert(hasRoute, check.Equals, false)
hasRoute = routertest.FakeRouter.HasRoute(app.GetName(), cont2.Address().String())
c.Assert(hasRoute, check.Equals, false)
containers := r.([]container.Container)
c.Assert(containers, check.DeepEquals, []container.Container{})
c.Assert(args.toRemove[0].Routable, check.Equals, true)
c.Assert(args.toRemove[1].Routable, check.Equals, true)
c.Assert(args.toRemove[2].Routable, check.Equals, false)
}
func (s *S) TestArchiveDeploy(c *gocheck.C) {
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
app := testing.NewFakeApp("myapp", "python", 1)
rtesting.FakeRouter.AddBackend(app.GetName())
defer rtesting.FakeRouter.RemoveBackend(app.GetName())
var buf bytes.Buffer
_, err = archiveDeploy(app, "https://s3.amazonaws.com/wat/archive.tar.gz", &buf)
c.Assert(err, gocheck.IsNil)
}
func (s *S) TestCreateContainerForward(c *check.C) {
config.Set("docker:user", "ubuntu")
defer config.Unset("docker:user")
err := s.newFakeImage(s.p, "tsuru/python", nil)
c.Assert(err, check.IsNil)
client, err := docker.NewClient(s.server.URL())
c.Assert(err, check.IsNil)
images, err := client.ListImages(docker.ListImagesOptions{All: true})
c.Assert(err, check.IsNil)
cmds := []string{"ps", "-ef"}
app := provisiontest.NewFakeApp("myapp", "python", 1)
cont := container.Container{Name: "myName", AppName: app.GetName(), Type: app.GetPlatform(), Status: "created"}
args := runContainerActionsArgs{
app: app,
imageID: images[0].ID,
commands: cmds,
provisioner: s.p,
buildingImage: images[0].ID,
isDeploy: true,
}
context := action.FWContext{Previous: cont, Params: []interface{}{args}}
r, err := createContainer.Forward(context)
c.Assert(err, check.IsNil)
cont = r.(container.Container)
defer cont.Remove(s.p)
c.Assert(cont, check.FitsTypeOf, container.Container{})
c.Assert(cont.ID, check.Not(check.Equals), "")
c.Assert(cont.HostAddr, check.Equals, "127.0.0.1")
dcli, err := docker.NewClient(s.server.URL())
c.Assert(err, check.IsNil)
cc, err := dcli.InspectContainer(cont.ID)
c.Assert(err, check.IsNil)
c.Assert(cc.State.Running, check.Equals, false)
c.Assert(cc.Config.User, check.Equals, "ubuntu")
args = runContainerActionsArgs{
app: app,
imageID: images[0].ID,
commands: cmds,
provisioner: s.p,
}
optsPull := docker.PullImageOptions{Repository: images[0].ID, OutputStream: nil}
err = s.p.Cluster().PullImage(optsPull, docker.AuthConfiguration{})
c.Assert(err, check.IsNil)
cont = container.Container{Name: "myName2", AppName: app.GetName(), Type: app.GetPlatform(), Status: "created"}
context = action.FWContext{Previous: cont, Params: []interface{}{args}}
r, err = createContainer.Forward(context)
c.Assert(err, check.IsNil)
cont = r.(container.Container)
defer cont.Remove(s.p)
cc, err = dcli.InspectContainer(cont.ID)
c.Assert(err, check.IsNil)
c.Assert(cc.Config.User, check.Equals, "")
}
func (s *S) TestArchiveDeploy(c *check.C) {
stopCh := s.stopContainers(s.server.URL(), 1)
defer func() { <-stopCh }()
err := s.newFakeImage(s.p, "tsuru/python:latest", nil)
c.Assert(err, check.IsNil)
app := provisiontest.NewFakeApp("myapp", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
var buf bytes.Buffer
_, err = s.p.archiveDeploy(app, s.p.getBuildImage(app), "https://s3.amazonaws.com/wat/archive.tar.gz", &buf)
c.Assert(err, check.IsNil)
}
func (s *S) TestContainerDeploy(c *gocheck.C) {
h := &testing.TestHandler{}
gandalfServer := testing.StartGandalfTestServer(h)
defer gandalfServer.Close()
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
app := testing.NewFakeApp("myapp", "python", 1)
rtesting.FakeRouter.AddBackend(app.GetName())
defer rtesting.FakeRouter.RemoveBackend(app.GetName())
var buf bytes.Buffer
_, err = deploy(app, "ff13e", &buf)
c.Assert(err, gocheck.IsNil)
}
func (s *S) TestAddRouteForward(c *gocheck.C) {
app := testing.NewFakeApp("myapp", "python", 1)
rtesting.FakeRouter.AddBackend(app.GetName())
defer rtesting.FakeRouter.RemoveBackend(app.GetName())
cont := container{ID: "ble", AppName: app.GetName()}
defer cont.remove()
context := action.FWContext{Previous: cont}
r, err := addRoute.Forward(context)
c.Assert(err, gocheck.IsNil)
cont = r.(container)
hasRoute := rtesting.FakeRouter.HasRoute(app.GetName(), cont.getAddress())
c.Assert(hasRoute, gocheck.Equals, true)
c.Assert(cont, gocheck.FitsTypeOf, container{})
}
func (s *S) TestRemoveOldRoutesForwardFailInMiddle(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
cont := container.Container{ID: "ble-1", AppName: app.GetName(), ProcessName: "web", HostAddr: "addr1"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "web", HostAddr: "addr2"}
defer cont.Remove(s.p)
defer cont2.Remove(s.p)
err := routertest.FakeRouter.AddRoute(app.GetName(), cont.Address())
c.Assert(err, check.IsNil)
err = routertest.FakeRouter.AddRoute(app.GetName(), cont2.Address())
c.Assert(err, check.IsNil)
routertest.FakeRouter.FailForIp(cont2.Address().String())
args := changeUnitsPipelineArgs{
app: app,
toRemove: []container.Container{cont, cont2},
provisioner: s.p,
}
context := action.FWContext{Previous: []container.Container{}, Params: []interface{}{args}}
_, err = removeOldRoutes.Forward(context)
c.Assert(err, check.Equals, routertest.ErrForcedFailure)
hasRoute := routertest.FakeRouter.HasRoute(app.GetName(), cont.Address().String())
c.Assert(hasRoute, check.Equals, true)
hasRoute = routertest.FakeRouter.HasRoute(app.GetName(), cont2.Address().String())
c.Assert(hasRoute, check.Equals, true)
c.Assert(args.toRemove[0].Routable, check.Equals, true)
c.Assert(args.toRemove[1].Routable, check.Equals, false)
}
func (s *S) TestExecuteCommandOnce(c *gocheck.C) {
var handler FakeSSHServer
handler.output = ". .."
server := httptest.NewServer(&handler)
defer server.Close()
host, port, _ := net.SplitHostPort(server.Listener.Addr().String())
portNumber, _ := strconv.Atoi(port)
config.Set("docker:ssh-agent-port", portNumber)
defer config.Unset("docker:ssh-agent-port")
app := testing.NewFakeApp("almah", "static", 1)
p := dockerProvisioner{}
container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container)
container.HostAddr = host
coll := collection()
defer coll.Close()
coll.Update(bson.M{"id": container.ID}, container)
var stdout, stderr bytes.Buffer
err = p.ExecuteCommandOnce(&stdout, &stderr, app, "ls", "-lh")
c.Assert(err, gocheck.IsNil)
c.Assert(stderr.Bytes(), gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, ". ..")
body := handler.bodies[0]
input := cmdInput{Cmd: "ls", Args: []string{"-lh"}}
c.Assert(body, gocheck.DeepEquals, input)
}
func (s *S) TestProvisionerRestartCallsTheRestartHook(c *gocheck.C) {
var handler FakeSSHServer
handler.output = "caad7bbd5411"
server := httptest.NewServer(&handler)
defer server.Close()
host, port, _ := net.SplitHostPort(server.Listener.Addr().String())
portNumber, _ := strconv.Atoi(port)
config.Set("docker:ssh-agent-port", portNumber)
defer config.Unset("docker:ssh-agent-port")
var p dockerProvisioner
app := testing.NewFakeApp("almah", "static", 1)
newImage("tsuru/python", s.server.URL())
cont, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(cont)
cont.HostAddr = host
coll := collection()
defer coll.Close()
err = coll.Update(bson.M{"id": cont.ID}, cont)
c.Assert(err, gocheck.IsNil)
err = p.Restart(app)
c.Assert(err, gocheck.IsNil)
input := cmdInput{Cmd: "/var/lib/tsuru/restart"}
body := handler.bodies[0]
c.Assert(body, gocheck.DeepEquals, input)
ip, _, _ := cont.networkInfo()
path := fmt.Sprintf("/container/%s/cmd", ip)
c.Assert(handler.requests[0].URL.Path, gocheck.DeepEquals, path)
}
func (s *S) TestProvisionerExecuteCommand(c *gocheck.C) {
var handler FakeSSHServer
handler.output = ". .."
server := httptest.NewServer(&handler)
defer server.Close()
host, port, _ := net.SplitHostPort(server.Listener.Addr().String())
portNumber, _ := strconv.Atoi(port)
config.Set("docker:ssh-agent-port", portNumber)
defer config.Unset("docker:ssh-agent-port")
app := testing.NewFakeApp("starbreaker", "python", 1)
container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container)
container.HostAddr = host
coll := collection()
defer coll.Close()
coll.Update(bson.M{"id": container.ID}, container)
var stdout, stderr bytes.Buffer
var p dockerProvisioner
err = p.ExecuteCommand(&stdout, &stderr, app, "ls", "-ar")
c.Assert(err, gocheck.IsNil)
c.Assert(stderr.Bytes(), gocheck.IsNil)
c.Assert(stdout.String(), gocheck.Equals, ". ..")
body := handler.bodies[0]
input := cmdInput{Cmd: "ls", Args: []string{"-ar"}}
c.Assert(body, gocheck.DeepEquals, input)
ip, _, _ := container.networkInfo()
path := fmt.Sprintf("/container/%s/cmd", ip)
c.Assert(handler.requests[0].URL.Path, gocheck.DeepEquals, path)
}
func (s *S) TestFollowLogsAndCommitForward(c *check.C) {
err := s.newFakeImage(s.p, "tsuru/python", nil)
c.Assert(err, check.IsNil)
app := provisiontest.NewFakeApp("mightyapp", "python", 1)
nextImgName, err := appNewImageName(app.GetName())
c.Assert(err, check.IsNil)
cont := container.Container{AppName: "mightyapp", ID: "myid123", BuildingImage: nextImgName}
err = cont.Create(&container.CreateArgs{
App: app,
ImageID: "tsuru/python",
Commands: []string{"foo"},
Provisioner: s.p,
})
c.Assert(err, check.IsNil)
buf := safe.NewBuffer(nil)
args := runContainerActionsArgs{writer: buf, provisioner: s.p}
context := action.FWContext{Params: []interface{}{args}, Previous: cont}
imageId, err := followLogsAndCommit.Forward(context)
c.Assert(err, check.IsNil)
c.Assert(imageId, check.Equals, "tsuru/app-mightyapp:v1")
c.Assert(buf.String(), check.Not(check.Equals), "")
var dbCont container.Container
coll := s.p.Collection()
defer coll.Close()
err = coll.Find(bson.M{"id": cont.ID}).One(&dbCont)
c.Assert(err, check.NotNil)
c.Assert(err.Error(), check.Equals, "not found")
_, err = s.p.Cluster().InspectContainer(cont.ID)
c.Assert(err, check.NotNil)
c.Assert(err.Error(), check.Matches, "No such container.*")
err = s.p.Cluster().RemoveImage("tsuru/app-mightyapp:v1")
c.Assert(err, check.IsNil)
}
func (s *S) TestProvisionerRestart(c *gocheck.C) {
var p dockerProvisioner
app := testing.NewFakeApp("almah", "static", 1)
container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container)
err = p.Start(app)
c.Assert(err, gocheck.IsNil)
dockerContainer, err := dCluster.InspectContainer(container.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer.State.Running, gocheck.Equals, true)
container.IP = ""
container.HostPort = ""
coll := collection()
defer coll.Close()
coll.Update(bson.M{"id": container.ID}, container)
err = p.Restart(app)
c.Assert(err, gocheck.IsNil)
dockerContainer, err = dCluster.InspectContainer(container.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer.State.Running, gocheck.Equals, true)
container, err = getContainer(container.ID)
c.Assert(err, gocheck.IsNil)
expectedIP := dockerContainer.NetworkSettings.IPAddress
expectedPort := dockerContainer.NetworkSettings.Ports["8888/tcp"][0].HostPort
c.Assert(container.IP, gocheck.Equals, expectedIP)
c.Assert(container.HostPort, gocheck.Equals, expectedPort)
c.Assert(container.Status, gocheck.Equals, provision.StatusStarted.String())
expectedSSHPort := dockerContainer.NetworkSettings.Ports["22/tcp"][0].HostPort
c.Assert(container.SSHHostPort, gocheck.Equals, expectedSSHPort)
}
func (s *S) TestProvisionerStart(c *gocheck.C) {
var p dockerProvisioner
app := testing.NewFakeApp("almah", "static", 1)
container, err := s.newContainer(&newContainerOpts{AppName: app.GetName()})
c.Assert(err, gocheck.IsNil)
defer s.removeTestContainer(container)
dcli, err := docker.NewClient(s.server.URL())
c.Assert(err, gocheck.IsNil)
dockerContainer, err := dcli.InspectContainer(container.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer.State.Running, gocheck.Equals, false)
err = p.Start(app)
c.Assert(err, gocheck.IsNil)
dockerContainer, err = dcli.InspectContainer(container.ID)
c.Assert(err, gocheck.IsNil)
c.Assert(dockerContainer.State.Running, gocheck.Equals, true)
container, err = getContainer(container.ID)
c.Assert(err, gocheck.IsNil)
expectedIP := dockerContainer.NetworkSettings.IPAddress
expectedPort := dockerContainer.NetworkSettings.Ports["8888/tcp"][0].HostPort
c.Assert(container.IP, gocheck.Equals, expectedIP)
c.Assert(container.HostPort, gocheck.Equals, expectedPort)
c.Assert(container.Status, gocheck.Equals, provision.StatusStarted.String())
expectedSSHPort := dockerContainer.NetworkSettings.Ports["22/tcp"][0].HostPort
c.Assert(container.SSHHostPort, gocheck.Equals, expectedSSHPort)
}