func (s *S) TestRebuildRoutesTCPRoutes(c *check.C) {
a := app.App{Name: "my-test-app", TeamOwner: s.team.Name}
err := app.CreateApp(&a, s.user)
c.Assert(err, check.IsNil)
err = provisiontest.ProvisionerInstance.AddUnits(&a, 3, "web", nil)
c.Assert(err, check.IsNil)
units, err := a.Units()
c.Assert(err, check.IsNil)
for _, u := range units {
routertest.FakeRouter.RemoveRoute(a.Name, u.Address)
routertest.FakeRouter.AddRoute(a.Name, &url.URL{Scheme: "tcp", Host: u.Address.Host})
}
changes, err := rebuild.RebuildRoutes(&a)
c.Assert(err, check.IsNil)
c.Assert(changes.Added, check.IsNil)
c.Assert(changes.Removed, check.IsNil)
routes, err := routertest.FakeRouter.Routes(a.Name)
c.Assert(err, check.IsNil)
c.Assert(routes, check.HasLen, 3)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[0].Address.Host), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[1].Address.Host), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[2].Address.Host), check.Equals, true)
app, err := app.GetByName(a.Name)
c.Assert(err, check.IsNil)
addr, err := routertest.FakeRouter.Addr(app.Name)
c.Assert(err, check.IsNil)
c.Assert(app.Ip, check.Equals, addr)
}
func (s *S) TestRebuildRoutes(c *check.C) {
a := app.App{Name: "my-test-app", TeamOwner: s.team.Name}
err := app.CreateApp(&a, s.user)
c.Assert(err, check.IsNil)
err = provisiontest.ProvisionerInstance.AddUnits(&a, 3, "web", nil)
c.Assert(err, check.IsNil)
units, err := a.Units()
c.Assert(err, check.IsNil)
routertest.FakeRouter.RemoveRoute(a.Name, units[2].Address)
routertest.FakeRouter.AddRoute(a.Name, &url.URL{Scheme: "http", Host: "invalid:1234"})
changes, err := rebuild.RebuildRoutes(&a)
c.Assert(err, check.IsNil)
c.Assert(changes.Added, check.DeepEquals, []string{units[2].Address.String()})
c.Assert(changes.Removed, check.DeepEquals, []string{"http://invalid:1234"})
routes, err := routertest.FakeRouter.Routes(a.Name)
c.Assert(err, check.IsNil)
c.Assert(routes, check.HasLen, 3)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[0].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[1].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[2].Address.String()), check.Equals, true)
app, err := app.GetByName(a.Name)
c.Assert(err, check.IsNil)
addr, err := routertest.FakeRouter.Addr(app.Name)
c.Assert(err, check.IsNil)
c.Assert(app.Ip, check.Equals, addr)
}
func (s *S) TestDeployRemoveContainersEvenWhenTheyreNotInTheAppsCollection(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(3)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
cont1, err := s.newContainer(nil)
defer s.removeTestContainer(cont1)
c.Assert(err, gocheck.IsNil)
cont2, err := s.newContainer(nil)
defer s.removeTestContainer(cont2)
c.Assert(err, gocheck.IsNil)
defer rtesting.FakeRouter.RemoveBackend(cont1.AppName)
var p dockerProvisioner
a := app.App{
Name: "otherapp",
Platform: "python",
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
fexec := &etesting.FakeExecutor{}
setExecut(fexec)
defer setExecut(nil)
var w bytes.Buffer
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: &w,
})
c.Assert(err, gocheck.IsNil)
time.Sleep(1e9)
defer p.Destroy(&a)
q, err := getQueue()
c.Assert(err, gocheck.IsNil)
for _, u := range a.Units() {
message, err := q.Get(1e6)
c.Assert(err, gocheck.IsNil)
c.Assert(message.Action, gocheck.Equals, app.BindService)
c.Assert(message.Args[0], gocheck.Equals, a.GetName())
c.Assert(message.Args[1], gocheck.Equals, u.Name)
}
coll := collection()
defer coll.Close()
n, err := coll.Find(bson.M{"appname": cont1.AppName}).Count()
c.Assert(err, gocheck.IsNil)
c.Assert(n, gocheck.Equals, 2)
}
func (s *S) TestRebuildRoutesAfterSwap(c *check.C) {
a1 := app.App{Name: "my-test-app-1", TeamOwner: s.team.Name}
err := app.CreateApp(&a1, s.user)
c.Assert(err, check.IsNil)
a2 := app.App{Name: "my-test-app-2", TeamOwner: s.team.Name}
err = app.CreateApp(&a2, s.user)
c.Assert(err, check.IsNil)
err = provisiontest.ProvisionerInstance.AddUnits(&a1, 3, "web", nil)
c.Assert(err, check.IsNil)
err = provisiontest.ProvisionerInstance.AddUnits(&a2, 2, "web", nil)
c.Assert(err, check.IsNil)
units1, err := a1.Units()
c.Assert(err, check.IsNil)
units2, err := a2.Units()
c.Assert(err, check.IsNil)
routertest.FakeRouter.AddRoute(a1.Name, &url.URL{Scheme: "http", Host: "invalid:1234"})
routertest.FakeRouter.RemoveRoute(a2.Name, units2[0].Address)
err = routertest.FakeRouter.Swap(a1.Name, a2.Name, false)
c.Assert(err, check.IsNil)
changes1, err := rebuild.RebuildRoutes(&a1)
c.Assert(err, check.IsNil)
changes2, err := rebuild.RebuildRoutes(&a2)
c.Assert(err, check.IsNil)
c.Assert(changes1.Added, check.IsNil)
c.Assert(changes1.Removed, check.DeepEquals, []string{"http://invalid:1234"})
c.Assert(changes2.Added, check.DeepEquals, []string{units2[0].Address.String()})
c.Assert(changes2.Removed, check.IsNil)
routes1, err := routertest.FakeRouter.Routes(a1.Name)
c.Assert(err, check.IsNil)
routes2, err := routertest.FakeRouter.Routes(a2.Name)
c.Assert(err, check.IsNil)
sort.Sort(URLList(routes1))
sort.Sort(URLList(routes2))
c.Assert(routes1, check.DeepEquals, []*url.URL{
units1[0].Address,
units1[1].Address,
units1[2].Address,
})
c.Assert(routes2, check.DeepEquals, []*url.URL{
units2[0].Address,
units2[1].Address,
})
c.Assert(routertest.FakeRouter.HasRoute(a1.Name, units2[0].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a1.Name, units2[1].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a2.Name, units1[0].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a2.Name, units1[1].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a2.Name, units1[2].Address.String()), check.Equals, true)
}
func (s *S) TestBindServiceForward(c *gocheck.C) {
a := app.App{Name: "cribcaged", Platform: "python"}
opts := app.DeployOptions{App: &a}
context := action.FWContext{Params: []interface{}{opts}}
_, err := bindService.Forward(context)
c.Assert(err, gocheck.IsNil)
q, err := getQueue()
c.Assert(err, gocheck.IsNil)
for _, u := range a.Units() {
message, err := q.Get(1e6)
c.Assert(err, gocheck.IsNil)
c.Assert(message.Action, gocheck.Equals, app.BindService)
c.Assert(message.Args[0], gocheck.Equals, a.GetName())
c.Assert(message.Args[1], gocheck.Equals, u.Name)
}
}
func minifyApp(app app.App) miniApp {
return miniApp{
Name: app.Name,
Units: app.Units(),
CName: app.CName,
Ip: app.Ip,
}
}
func (s *S) TestDeploy(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
setExecut(&etesting.FakeExecutor{})
defer setExecut(nil)
p := dockerProvisioner{}
a := app.App{
Name: "otherapp",
Platform: "python",
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
w := safe.NewBuffer(make([]byte, 2048))
var serviceBodies []string
rollback := s.addServiceInstance(c, a.Name, func(w http.ResponseWriter, r *http.Request) {
data, _ := ioutil.ReadAll(r.Body)
serviceBodies = append(serviceBodies, string(data))
w.WriteHeader(http.StatusOK)
})
defer rollback()
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: w,
})
c.Assert(err, gocheck.IsNil)
units := a.Units()
c.Assert(units, gocheck.HasLen, 1)
c.Assert(serviceBodies, gocheck.HasLen, 1)
c.Assert(serviceBodies[0], gocheck.Matches, ".*unit-host="+units[0].Ip)
}
func (s *S) TestDeployEnqueuesBindService(c *gocheck.C) {
h := &tsrTesting.TestHandler{}
gandalfServer := tsrTesting.StartGandalfTestServer(h)
defer gandalfServer.Close()
go s.stopContainers(1)
err := newImage("tsuru/python", s.server.URL())
c.Assert(err, gocheck.IsNil)
setExecut(&etesting.FakeExecutor{})
defer setExecut(nil)
p := dockerProvisioner{}
app.Provisioner = &p
a := app.App{
Name: "otherapp",
Platform: "python",
}
conn, err := db.Conn()
defer conn.Close()
err = conn.Apps().Insert(a)
c.Assert(err, gocheck.IsNil)
defer conn.Apps().Remove(bson.M{"name": a.Name})
p.Provision(&a)
defer p.Destroy(&a)
w := safe.NewBuffer(make([]byte, 2048))
err = app.Deploy(app.DeployOptions{
App: &a,
Version: "master",
Commit: "123",
OutputStream: w,
})
c.Assert(err, gocheck.IsNil)
defer p.Destroy(&a)
q, err := getQueue()
c.Assert(err, gocheck.IsNil)
for _, u := range a.Units() {
message, err := q.Get(1e6)
c.Assert(err, gocheck.IsNil)
c.Assert(message.Action, gocheck.Equals, app.BindService)
c.Assert(message.Args[0], gocheck.Equals, a.GetName())
c.Assert(message.Args[1], gocheck.Equals, u.Name)
}
}
func minifyApp(app app.App) (miniApp, error) {
units, err := app.Units()
if err != nil {
return miniApp{}, err
}
return miniApp{
Name: app.GetName(),
Units: units,
CName: app.GetCname(),
Ip: app.GetIp(),
Lock: app.GetLock(),
}, nil
}
func minifyApp(app app.App) (miniApp, error) {
units, err := app.Units()
if err != nil {
return miniApp{}, err
}
return miniApp{
Name: app.Name,
Units: units,
CName: app.CName,
Ip: app.Ip,
Lock: app.Lock,
}, nil
}
func (s *S) TestRebuildRoutesRecreatesCnames(c *check.C) {
a := app.App{Name: "my-test-app", TeamOwner: s.team.Name}
err := app.CreateApp(&a, s.user)
c.Assert(err, check.IsNil)
err = provisiontest.ProvisionerInstance.AddUnits(&a, 1, "web", nil)
c.Assert(err, check.IsNil)
units, err := a.Units()
c.Assert(err, check.IsNil)
err = a.AddCName("my.cname.com")
c.Assert(err, check.IsNil)
c.Assert(routertest.FakeRouter.HasCName("my.cname.com"), check.Equals, true)
err = routertest.FakeRouter.UnsetCName("my.cname.com", a.Name)
c.Assert(err, check.IsNil)
c.Assert(routertest.FakeRouter.HasCName("my.cname.com"), check.Equals, false)
changes, err := rebuild.RebuildRoutes(&a)
c.Assert(err, check.IsNil)
c.Assert(changes, check.DeepEquals, &rebuild.RebuildRoutesResult{})
routes, err := routertest.FakeRouter.Routes(a.Name)
c.Assert(err, check.IsNil)
c.Assert(routes, check.HasLen, 1)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[0].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasCName("my.cname.com"), check.Equals, true)
}
func (s *S) TestRebuildRoutesRecreatesBackend(c *check.C) {
a := app.App{Name: "my-test-app", TeamOwner: s.team.Name}
err := app.CreateApp(&a, s.user)
c.Assert(err, check.IsNil)
err = provisiontest.ProvisionerInstance.AddUnits(&a, 3, "web", nil)
c.Assert(err, check.IsNil)
units, err := a.Units()
c.Assert(err, check.IsNil)
routertest.FakeRouter.RemoveBackend(a.Name)
changes, err := rebuild.RebuildRoutes(&a)
c.Assert(err, check.IsNil)
sort.Strings(changes.Added)
c.Assert(changes.Added, check.DeepEquals, []string{
units[0].Address.String(),
units[1].Address.String(),
units[2].Address.String(),
})
routes, err := routertest.FakeRouter.Routes(a.Name)
c.Assert(err, check.IsNil)
c.Assert(routes, check.HasLen, 3)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[0].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[1].Address.String()), check.Equals, true)
c.Assert(routertest.FakeRouter.HasRoute(a.Name, units[2].Address.String()), check.Equals, true)
}