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) TestCreateContainerForward(c *check.C) {
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,
}
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)
}
func (s *S) TestAddNewRouteForwardNoWeb(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
imageName := "tsuru/app-" + app.GetName()
customData := map[string]interface{}{
"processes": map[string]interface{}{
"api": "python myapi.py",
},
}
err := saveImageCustomData(imageName, customData)
c.Assert(err, check.IsNil)
cont1 := container.Container{ID: "ble-1", AppName: app.GetName(), ProcessName: "api", HostAddr: "127.0.0.1", HostPort: "1234"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "api", HostAddr: "127.0.0.2", HostPort: "4321"}
defer cont1.Remove(s.p)
defer cont2.Remove(s.p)
args := changeUnitsPipelineArgs{
app: app,
provisioner: s.p,
imageId: imageName,
}
context := action.FWContext{Previous: []container.Container{cont1, cont2}, Params: []interface{}{args}}
r, err := addNewRoutes.Forward(context)
c.Assert(err, check.IsNil)
containers := r.([]container.Container)
hasRoute := routertest.FakeRouter.HasRoute(app.GetName(), cont1.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(containers, check.HasLen, 2)
c.Assert(containers[0].Routable, check.Equals, true)
c.Assert(containers[0].ID, check.Equals, "ble-1")
c.Assert(containers[1].Routable, check.Equals, true)
c.Assert(containers[1].ID, check.Equals, "ble-2")
}
func (s *S) TestAddNewRouteForwardFailInMiddle(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: "", HostAddr: "addr1", HostPort: "4321"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "", HostAddr: "addr2", HostPort: "8080"}
defer cont.Remove(s.p)
defer cont2.Remove(s.p)
routertest.FakeRouter.FailForIp(cont2.Address().String())
args := changeUnitsPipelineArgs{
app: app,
provisioner: s.p,
}
prevContainers := []container.Container{cont, cont2}
context := action.FWContext{Previous: prevContainers, Params: []interface{}{args}}
_, err := addNewRoutes.Forward(context)
c.Assert(err, check.Equals, routertest.ErrForcedFailure)
hasRoute := routertest.FakeRouter.HasRoute(app.GetName(), cont.Address().String())
c.Assert(hasRoute, check.Equals, false)
hasRoute = routertest.FakeRouter.HasRoute(app.GetName(), cont2.Address().String())
c.Assert(hasRoute, check.Equals, false)
c.Assert(prevContainers[0].Routable, check.Equals, true)
c.Assert(prevContainers[0].ID, check.Equals, "ble-1")
c.Assert(prevContainers[1].Routable, check.Equals, false)
c.Assert(prevContainers[1].ID, check.Equals, "ble-2")
}
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) 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) 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) TestRemoveOldRoutesBackward(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"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "web"}
defer cont.Remove(s.p)
defer cont2.Remove(s.p)
cont.Routable = true
cont2.Routable = true
args := changeUnitsPipelineArgs{
app: app,
toRemove: []container.Container{cont, cont2},
provisioner: s.p,
}
context := action.BWContext{Params: []interface{}{args}}
removeOldRoutes.Backward(context)
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)
}
func (s *S) TestRemoveOldRoutesForwardFailInMiddle(c *check.C) {
app := provisiontest.NewFakeApp("myapp", "python", 1)
imageName := "tsuru/app-" + app.GetName()
customData := map[string]interface{}{
"processes": map[string]interface{}{
"web": "python myapi.py",
"worker": "tail -f /dev/null",
},
}
err := saveImageCustomData(imageName, customData)
c.Assert(err, check.IsNil)
routertest.FakeRouter.AddBackend(app.GetName())
defer routertest.FakeRouter.RemoveBackend(app.GetName())
cont := container.Container{ID: "ble-1", AppName: app.GetName(), ProcessName: "web", HostAddr: "addr1", HostPort: "1234"}
cont2 := container.Container{ID: "ble-2", AppName: app.GetName(), ProcessName: "web", HostAddr: "addr2", HostPort: "1234"}
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, true)
}
func (s *S) TestGetRemovableContainer(c *check.C) {
a1 := app.App{Name: "impius", Teams: []string{"tsuruteam", "nodockerforme"}, Pool: "pool1"}
cont1 := container.Container{ID: "1", Name: "impius1", AppName: a1.Name, ProcessName: "web"}
cont2 := container.Container{ID: "2", Name: "mirror1", AppName: a1.Name, ProcessName: "worker"}
a2 := app.App{Name: "notimpius", Teams: []string{"tsuruteam", "nodockerforme"}, Pool: "pool1"}
cont3 := container.Container{ID: "3", Name: "dedication1", AppName: a2.Name, ProcessName: "web"}
cont4 := container.Container{ID: "4", Name: "dedication2", AppName: a2.Name, ProcessName: "worker"}
err := s.storage.Apps().Insert(a1)
c.Assert(err, check.IsNil)
err = s.storage.Apps().Insert(a2)
c.Assert(err, check.IsNil)
defer s.storage.Apps().RemoveAll(bson.M{"name": a1.Name})
defer s.storage.Apps().RemoveAll(bson.M{"name": a2.Name})
p := provision.Pool{Name: "pool1", Teams: []string{
"tsuruteam",
"nodockerforme",
}}
o := provision.AddPoolOptions{Name: p.Name}
err = provision.AddPool(o)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool(p.Name, p.Teams)
defer provision.RemovePool(p.Name)
contColl := s.p.Collection()
defer contColl.Close()
err = contColl.Insert(
cont1, cont2, cont3, cont4,
)
c.Assert(err, check.IsNil)
defer contColl.RemoveAll(bson.M{"name": bson.M{"$in": []string{cont1.Name, cont2.Name, cont3.Name, cont4.Name}}})
scheduler := segregatedScheduler{provisioner: s.p}
clusterInstance, err := cluster.New(&scheduler, &cluster.MapStorage{})
s.p.cluster = clusterInstance
c.Assert(err, check.IsNil)
server1, err := testing.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
defer server1.Stop()
server2, err := testing.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
defer server2.Stop()
localURL := strings.Replace(server2.URL(), "127.0.0.1", "localhost", -1)
err = clusterInstance.Register(cluster.Node{
Address: server1.URL(),
Metadata: map[string]string{"pool": "pool1"},
})
c.Assert(err, check.IsNil)
err = clusterInstance.Register(cluster.Node{
Address: localURL,
Metadata: map[string]string{"pool": "pool1"},
})
c.Assert(err, check.IsNil)
opts := docker.CreateContainerOptions{Name: cont1.Name}
_, err = scheduler.Schedule(clusterInstance, opts, []string{a1.Name, cont1.ProcessName})
c.Assert(err, check.IsNil)
opts = docker.CreateContainerOptions{Name: cont2.Name}
_, err = scheduler.Schedule(clusterInstance, opts, []string{a1.Name, cont2.ProcessName})
c.Assert(err, check.IsNil)
opts = docker.CreateContainerOptions{Name: cont3.Name}
_, err = scheduler.Schedule(clusterInstance, opts, []string{a2.Name, cont3.ProcessName})
c.Assert(err, check.IsNil)
opts = docker.CreateContainerOptions{Name: cont4.Name}
_, err = scheduler.Schedule(clusterInstance, opts, []string{a2.Name, cont4.ProcessName})
c.Assert(err, check.IsNil)
cont, err := scheduler.GetRemovableContainer(a1.Name, "web")
c.Assert(err, check.IsNil)
c.Assert(cont, check.Equals, cont1.ID)
err = cont1.Remove(s.p)
c.Assert(err, check.IsNil)
_, err = scheduler.GetRemovableContainer(a1.Name, "web")
c.Assert(err, check.NotNil)
}
func (s *S) removeTestContainer(c *container.Container) error {
routertest.FakeRouter.RemoveBackend(c.AppName)
return c.Remove(s.p)
}
