func (s *S) TestSchedulerNoNodesWithDefaultPool(c *check.C) {
provision.RemovePool("test-default")
app := app.App{Name: "bill", Teams: []string{"jean"}}
err := s.storage.Apps().Insert(app)
c.Assert(err, check.IsNil)
defer s.storage.Apps().Remove(bson.M{"name": app.Name})
scheduler := segregatedScheduler{provisioner: s.p}
clusterInstance, err := cluster.New(&scheduler, &cluster.MapStorage{})
c.Assert(err, check.IsNil)
o := provision.AddPoolOptions{Name: "mypool"}
err = provision.AddPool(o)
c.Assert(err, check.IsNil)
o = provision.AddPoolOptions{Name: "mypool2"}
err = provision.AddPool(o)
c.Assert(err, check.IsNil)
defer provision.RemovePool("mypool")
defer provision.RemovePool("mypool2")
provision.AddTeamsToPool("mypool", []string{"jean"})
provision.AddTeamsToPool("mypool2", []string{"jean"})
opts := docker.CreateContainerOptions{}
schedOpts := []string{app.Name, "web"}
node, err := scheduler.Schedule(clusterInstance, opts, schedOpts)
c.Assert(node.Address, check.Equals, "")
c.Assert(err, check.NotNil)
c.Assert(err.Error(), check.Matches, "No nodes found with one of the following metadata: pool=mypool, pool=mypool2")
}
func (s *S) startMultipleServersClusterSeggregated() (*dockerProvisioner, error) {
var err error
s.extraServer, err = dtesting.NewServer("localhost:0", nil, nil)
if err != nil {
return nil, err
}
otherURL := strings.Replace(s.extraServer.URL(), "127.0.0.1", "localhost", 1)
var p dockerProvisioner
err = p.Initialize()
if err != nil {
return nil, err
}
opts := provision.AddPoolOptions{Name: "pool1", Public: true}
err = provision.AddPool(opts)
if err != nil {
return nil, err
}
opts = provision.AddPoolOptions{Name: "pool2", Public: true}
err = provision.AddPool(opts)
if err != nil {
return nil, err
}
p.storage = &cluster.MapStorage{}
sched := segregatedScheduler{provisioner: &p}
p.cluster, err = cluster.New(&sched, p.storage,
cluster.Node{Address: s.server.URL(), Metadata: map[string]string{"pool": "pool1"}},
cluster.Node{Address: otherURL, Metadata: map[string]string{"pool": "pool2"}},
)
if err != nil {
return nil, err
}
return &p, nil
}
func (s *S) TestPoolListHandler(c *check.C) {
team := auth.Team{Name: "angra"}
err := s.conn.Teams().Insert(team)
c.Assert(err, check.IsNil)
token := userWithPermission(c, permission.Permission{
Scheme: permission.PermAppCreate,
Context: permission.Context(permission.CtxTeam, "angra"),
})
pool := provision.Pool{Name: "pool1", Teams: []string{"angra"}}
opts := provision.AddPoolOptions{Name: pool.Name}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool(pool.Name, pool.Teams)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
opts = provision.AddPoolOptions{Name: "nopool"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("nopool")
defaultPools, err := provision.ListPools(bson.M{"default": true})
c.Assert(err, check.IsNil)
expected := []provision.Pool{
defaultPools[0],
{Name: "pool1", Teams: []string{"angra"}},
}
req, err := http.NewRequest("GET", "/pools", nil)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = poolList(rec, req, token)
c.Assert(err, check.IsNil)
var pools []provision.Pool
err = json.NewDecoder(rec.Body).Decode(&pools)
c.Assert(err, check.IsNil)
c.Assert(pools, check.DeepEquals, expected)
}
func (s *S) TestListPoolsToUserHandler(c *check.C) {
u := auth.User{Email: "*****@*****.**", Password: "******"}
_, err := nativeScheme.Create(&u)
c.Assert(err, check.IsNil)
defer s.conn.Users().Remove(bson.M{"email": u.Email})
token, err := nativeScheme.Login(map[string]string{"email": u.Email, "password": "******"})
c.Assert(err, check.IsNil)
defer s.conn.Tokens().Remove(bson.M{"token": token.GetValue()})
team := auth.Team{Name: "angra", Users: []string{s.user.Email, u.Email}}
err = s.conn.Teams().Insert(team)
c.Assert(err, check.IsNil)
defer s.conn.Teams().Remove(bson.M{"_id": team.Name})
pool := provision.Pool{Name: "pool1", Teams: []string{"angra"}}
err = provision.AddPool(pool.Name, false)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool(pool.Name, pool.Teams)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
err = provision.AddPool("nopool", false)
c.Assert(err, check.IsNil)
defer provision.RemovePool("nopool")
poolsExpected := map[string]interface{}{
"pools_by_team": []interface{}{map[string]interface{}{"Team": "angra", "Pools": []interface{}{"pool1"}}},
"public_pools": interface{}(nil),
}
req, err := http.NewRequest("GET", "/pool", nil)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = listPoolsToUser(rec, req, token)
c.Assert(err, check.IsNil)
var pools map[string]interface{}
err = json.NewDecoder(rec.Body).Decode(&pools)
c.Assert(err, check.IsNil)
c.Assert(pools, check.DeepEquals, poolsExpected)
}
func (s *S) TestListPoolsToUserHandler(c *check.C) {
team := auth.Team{Name: "angra"}
err := s.conn.Teams().Insert(team)
c.Assert(err, check.IsNil)
token := userWithPermission(c, permission.Permission{
Scheme: permission.PermAppCreate,
Context: permission.Context(permission.CtxTeam, "angra"),
})
pool := provision.Pool{Name: "pool1", Teams: []string{"angra"}}
opts := provision.AddPoolOptions{Name: pool.Name}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool(pool.Name, pool.Teams)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
opts = provision.AddPoolOptions{Name: "nopool"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("nopool")
poolsExpected := map[string]interface{}{
"pools_by_team": []interface{}{map[string]interface{}{"Team": "angra", "Pools": []interface{}{"pool1"}}},
"public_pools": []interface{}{},
"default_pool": []interface{}{},
}
req, err := http.NewRequest("GET", "/pool", nil)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = listPoolsToUser(rec, req, token)
c.Assert(err, check.IsNil)
var pools map[string]interface{}
err = json.NewDecoder(rec.Body).Decode(&pools)
c.Assert(err, check.IsNil)
c.Assert(pools, check.DeepEquals, poolsExpected)
}
func (s *S) TestAddNodeHandlerExisting(c *check.C) {
opts := provision.AddPoolOptions{Name: "pool1"}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
serverAddr := "http://mysrv1"
params := provision.AddNodeOptions{
Register: true,
Metadata: map[string]string{
"address": serverAddr,
"pool": "pool1",
},
}
v, err := form.EncodeToValues(¶ms)
c.Assert(err, check.IsNil)
req, err := http.NewRequest("POST", "/1.2/node", strings.NewReader(v.Encode()))
c.Assert(err, check.IsNil)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Authorization", s.token.GetValue())
rec := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(rec, req)
c.Assert(rec.Code, check.Equals, http.StatusCreated)
req, err = http.NewRequest("POST", "/1.2/node", strings.NewReader(v.Encode()))
c.Assert(err, check.IsNil)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Authorization", s.token.GetValue())
rec = httptest.NewRecorder()
m.ServeHTTP(rec, req)
var result map[string]string
err = json.NewDecoder(rec.Body).Decode(&result)
c.Assert(err, check.IsNil)
c.Assert(result["Error"], check.Equals, "node with address \"http://mysrv1\" already exists in provisioner \"fake\"")
c.Assert(rec.Code, check.Equals, http.StatusCreated)
}
func (s *S) TestSchedulerScheduleFallback(c *check.C) {
a1 := app.App{Name: "impius", Teams: []string{"tsuruteam", "nodockerforme"}}
cont1 := container{ID: "1", Name: "impius1", AppName: a1.Name}
err := s.storage.Apps().Insert(a1)
c.Assert(err, check.IsNil)
defer s.storage.Apps().RemoveAll(bson.M{"name": a1.Name})
p := provision.Pool{Name: "pool1", Teams: []string{}}
o := provision.AddPoolOptions{Name: p.Name}
err = provision.AddPool(o)
c.Assert(err, check.IsNil)
defer provision.RemovePool(p.Name)
contColl := s.p.collection()
defer contColl.Close()
err = contColl.Insert(cont1)
c.Assert(err, check.IsNil)
defer contColl.RemoveAll(bson.M{"name": cont1.Name})
scheduler := segregatedScheduler{provisioner: s.p}
clusterInstance, err := cluster.New(&scheduler, &cluster.MapStorage{})
s.p.cluster = clusterInstance
c.Assert(err, check.IsNil)
_, err = clusterInstance.Register("http://url0:1234", map[string]string{"pool": "pool1"})
c.Assert(err, check.IsNil)
opts := docker.CreateContainerOptions{Name: cont1.Name}
node, err := scheduler.Schedule(clusterInstance, opts, []string{a1.Name, "web"})
c.Assert(err, check.IsNil)
c.Check(node.Address, check.Equals, "http://url0:1234")
}
func (s *S) SetUpTest(c *check.C) {
config.Set("docker:api-timeout", 2)
iaas.ResetAll()
repositorytest.Reset()
queue.ResetQueue()
repository.Manager().CreateUser(s.user.Email)
s.p = &dockerProvisioner{storage: &cluster.MapStorage{}}
err := s.p.Initialize()
c.Assert(err, check.IsNil)
queue.ResetQueue()
s.server, err = dtesting.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
s.p.cluster, err = cluster.New(nil, s.p.storage,
cluster.Node{Address: s.server.URL(), Metadata: map[string]string{"pool": "test-default"}},
)
c.Assert(err, check.IsNil)
mainDockerProvisioner = s.p
err = dbtest.ClearAllCollectionsExcept(s.storage.Apps().Database, []string{"users", "tokens", "teams"})
c.Assert(err, check.IsNil)
err = clearClusterStorage(s.clusterSess)
c.Assert(err, check.IsNil)
routertest.FakeRouter.Reset()
opts := provision.AddPoolOptions{Name: "test-default", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
s.storage.Tokens().Remove(bson.M{"appname": bson.M{"$ne": ""}})
s.logBuf = safe.NewBuffer(nil)
log.SetLogger(log.NewWriterLogger(s.logBuf, true))
s.token = createTokenForUser(s.user, "*", string(permission.CtxGlobal), "", c)
}
func addPoolHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
allowed := permission.Check(t, permission.PermPoolCreate)
if !allowed {
return permission.ErrUnauthorized
}
b, err := ioutil.ReadAll(r.Body)
if err != nil {
return err
}
var p provision.AddPoolOptions
err = json.Unmarshal(b, &p)
if err != nil {
return err
}
forceAdd, _ := strconv.ParseBool(r.URL.Query().Get("force"))
p.Force = forceAdd
err = provision.AddPool(p)
if err != nil {
if err == provision.ErrDefaultPoolAlreadyExists {
return &terrors.HTTP{
Code: http.StatusConflict,
Message: "Default pool already exists.",
}
}
return err
}
return nil
}
func (s *S) SetUpTest(c *check.C) {
iaas.ResetAll()
repositorytest.Reset()
queue.ResetQueue()
s.p = &dockerProvisioner{storage: &cluster.MapStorage{}}
err := s.p.Initialize()
c.Assert(err, check.IsNil)
queue.ResetQueue()
app.Provisioner = s.p
s.server, err = dtesting.NewServer("127.0.0.1:0", nil, nil)
c.Assert(err, check.IsNil)
s.p.cluster, err = cluster.New(nil, s.p.storage,
cluster.Node{Address: s.server.URL(), Metadata: map[string]string{"pool": "test-fallback"}},
)
c.Assert(err, check.IsNil)
mainDockerProvisioner = s.p
coll := s.p.collection()
defer coll.Close()
err = dbtest.ClearAllCollectionsExcept(coll.Database, []string{"users", "tokens", "teams"})
c.Assert(err, check.IsNil)
err = clearClusterStorage(s.clusterSess)
c.Assert(err, check.IsNil)
routertest.FakeRouter.Reset()
opts := provision.AddPoolOptions{Name: "test-fallback"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
}
func (s *S) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
rand.Seed(0)
config.Set("swarm:swarm-port", 0)
err := dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
err = provision.AddPool(provision.AddPoolOptions{Name: "bonehunters", Default: true, Provisioner: "swarm"})
c.Assert(err, check.IsNil)
p := app.Plan{
Name: "default",
Router: "fake",
Default: true,
CpuShare: 100,
}
err = p.Save()
c.Assert(err, check.IsNil)
s.p = &swarmProvisioner{}
err = s.p.Initialize()
c.Assert(err, check.IsNil)
s.user = &auth.User{Email: "*****@*****.**", Password: "******", Quota: quota.Unlimited}
nativeScheme := auth.ManagedScheme(native.NativeScheme{})
app.AuthScheme = nativeScheme
_, err = nativeScheme.Create(s.user)
c.Assert(err, check.IsNil)
s.team = &auth.Team{Name: "admin"}
c.Assert(err, check.IsNil)
err = s.conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
s.token, err = nativeScheme.Login(map[string]string{"email": s.user.Email, "password": "******"})
c.Assert(err, check.IsNil)
}
func (s *S) TestUpdateNodeEnableNodeHandler(c *check.C) {
err := s.provisioner.AddNode(provision.AddNodeOptions{
Address: "localhost:1999",
})
c.Assert(err, check.IsNil)
opts := provision.AddPoolOptions{Name: "pool1"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
params := provision.UpdateNodeOptions{
Address: "localhost:1999",
Enable: true,
}
v, err := form.EncodeToValues(¶ms)
c.Assert(err, check.IsNil)
b := strings.NewReader(v.Encode())
recorder := httptest.NewRecorder()
request, err := http.NewRequest("PUT", "/node", b)
c.Assert(err, check.IsNil)
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
nodes, err := s.provisioner.ListNodes(nil)
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Status(), check.Equals, "enabled")
}
func (s *S) TestUpdateNodeEnableAndDisableCantBeDone(c *check.C) {
err := s.provisioner.AddNode(provision.AddNodeOptions{
Address: "localhost:1999",
})
c.Assert(err, check.IsNil)
opts := provision.AddPoolOptions{Name: "pool1"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
params := provision.UpdateNodeOptions{
Address: "localhost:1999",
Enable: true,
Disable: true,
}
v, err := form.EncodeToValues(¶ms)
c.Assert(err, check.IsNil)
b := strings.NewReader(v.Encode())
recorder := httptest.NewRecorder()
request, err := http.NewRequest("PUT", "/node", b)
c.Assert(err, check.IsNil)
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusBadRequest)
c.Assert(recorder.Body.String(), check.Equals, "A node can't be enabled and disabled simultaneously.\n")
}
func (s *S) TestPoolUpdateProvisioner(c *check.C) {
provision.RemovePool("test1")
opts := provision.AddPoolOptions{Name: "pool1", Public: true, Default: true}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
b := bytes.NewBufferString("provisioner=myprov&default=false")
req, err := http.NewRequest("PUT", "/pools/pool1", b)
c.Assert(err, check.IsNil)
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Authorization", "bearer "+s.token.GetValue())
rec := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(rec, req)
c.Assert(rec.Code, check.Equals, http.StatusOK)
c.Assert(err, check.IsNil)
p, err := provision.GetPoolByName("pool1")
c.Assert(err, check.IsNil)
c.Assert(p.Provisioner, check.Equals, "myprov")
c.Assert(p.Public, check.Equals, true)
c.Assert(p.Default, check.Equals, false)
c.Assert(eventtest.EventDesc{
Target: event.Target{Type: event.TargetTypePool, Value: "pool1"},
Owner: s.token.GetUserName(),
Kind: "pool.update",
StartCustomData: []map[string]interface{}{
{"name": ":name", "value": "pool1"},
{"name": "default", "value": "false"},
{"name": "provisioner", "value": "myprov"},
},
}, eventtest.HasEvent)
}
func (s *S) TestRemoveTeamsToPoolHandler(c *check.C) {
pool := provision.Pool{Name: "pool1", Teams: []string{"test"}}
opts := provision.AddPoolOptions{Name: pool.Name}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool(pool.Name, pool.Teams)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
req, err := http.NewRequest("DELETE", "/pools/pool1/team?team=test", nil)
c.Assert(err, check.IsNil)
req.Header.Set("Authorization", "bearer "+s.token.GetValue())
rec := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(rec, req)
c.Assert(rec.Code, check.Equals, http.StatusOK)
var p provision.Pool
err = s.conn.Pools().FindId(pool.Name).One(&p)
c.Assert(err, check.IsNil)
c.Assert(p.Teams, check.DeepEquals, []string{})
c.Assert(eventtest.EventDesc{
Target: event.Target{Type: event.TargetTypePool, Value: "pool1"},
Owner: s.token.GetUserName(),
Kind: "pool.update.team.remove",
StartCustomData: []map[string]interface{}{
{"name": ":name", "value": "pool1"},
{"name": "team", "value": "test"},
},
}, eventtest.HasEvent)
}
func (s *S) TestAddTeamsToPool(c *check.C) {
pool := provision.Pool{Name: "pool1"}
opts := provision.AddPoolOptions{Name: pool.Name}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
b := strings.NewReader("team=test")
req, err := http.NewRequest("POST", "/pools/pool1/team", b)
c.Assert(err, check.IsNil)
req.Header.Set("Authorization", "bearer "+s.token.GetValue())
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
rec := httptest.NewRecorder()
m := RunServer(true)
m.ServeHTTP(rec, req)
c.Assert(rec.Code, check.Equals, http.StatusOK)
p, err := provision.GetPoolByName("pool1")
c.Assert(err, check.IsNil)
c.Assert(p.Teams, check.DeepEquals, []string{"test"})
c.Assert(eventtest.EventDesc{
Target: event.Target{Type: event.TargetTypePool, Value: "pool1"},
Owner: s.token.GetUserName(),
Kind: "pool.update.team.add",
StartCustomData: []map[string]interface{}{
{"name": ":name", "value": "pool1"},
{"name": "team", "value": "test"},
},
}, eventtest.HasEvent)
}
func (s *S) SetUpTest(c *check.C) {
queue.ResetQueue()
err := rebuild.RegisterTask(func(appName string) (rebuild.RebuildApp, error) {
a, err := app.GetByName(appName)
if err == app.ErrAppNotFound {
return nil, nil
}
return a, err
})
c.Assert(err, check.IsNil)
routertest.FakeRouter.Reset()
provisiontest.ProvisionerInstance.Reset()
err = dbtest.ClearAllCollections(s.conn.Apps().Database)
c.Assert(err, check.IsNil)
s.user = &auth.User{Email: "*****@*****.**", Password: "******", Quota: quota.Unlimited}
nativeScheme := auth.ManagedScheme(native.NativeScheme{})
app.AuthScheme = nativeScheme
_, err = nativeScheme.Create(s.user)
c.Assert(err, check.IsNil)
s.team = &auth.Team{Name: "admin"}
c.Assert(err, check.IsNil)
err = s.conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
err = provision.AddPool(provision.AddPoolOptions{
Name: "p1",
Default: true,
Provisioner: "fake",
})
c.Assert(err, check.IsNil)
}
func (s *S) SetUpTest(c *check.C) {
routertest.FakeRouter.Reset()
repositorytest.Reset()
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.logConn, err = db.LogConn()
c.Assert(err, check.IsNil)
s.createUserAndTeam(c)
s.provisioner = provisiontest.NewFakeProvisioner()
app.Provisioner = s.provisioner
app.AuthScheme = nativeScheme
p := app.Platform{Name: "zend"}
s.conn.Platforms().Insert(p)
s.Pool = "test1"
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
repository.Manager().CreateUser(s.adminuser.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func (s *S) TestPoolListHandlerWithPermissionToDefault(c *check.C) {
team := auth.Team{Name: "angra"}
err := s.conn.Teams().Insert(team)
c.Assert(err, check.IsNil)
perms := []permission.Permission{
{
Scheme: permission.PermAppCreate,
Context: permission.Context(permission.CtxGlobal, ""),
},
{
Scheme: permission.PermPoolUpdate,
Context: permission.Context(permission.CtxGlobal, ""),
},
}
token := userWithPermission(c, perms...)
pool := provision.Pool{Name: "pool1", Teams: []string{team.Name}}
opts := provision.AddPoolOptions{Name: pool.Name, Default: pool.Default}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool(pool.Name, pool.Teams)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
req, err := http.NewRequest("GET", "/pools", nil)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = poolList(rec, req, token)
c.Assert(err, check.IsNil)
var pools []provision.Pool
err = json.NewDecoder(rec.Body).Decode(&pools)
c.Assert(err, check.IsNil)
c.Assert(pools, check.HasLen, 2)
c.Assert(pools[0].Name, check.Equals, "test1")
c.Assert(pools[1].Name, check.Equals, "pool1")
}
func (s *HandlersSuite) TestUpdateNodeHandler(c *check.C) {
mainDockerProvisioner.cluster, _ = cluster.New(&segregatedScheduler{}, &cluster.MapStorage{},
cluster.Node{Address: "localhost:1999", Metadata: map[string]string{
"m1": "v1",
"m2": "v2",
}},
)
opts := provision.AddPoolOptions{Name: "pool1"}
err := provision.AddPool(opts)
defer provision.RemovePool("pool1")
json := `{"address": "localhost:1999", "m1": "", "m2": "v9", "m3": "v8"}`
b := bytes.NewBufferString(json)
recorder := httptest.NewRecorder()
request, err := http.NewRequest("PUT", "/docker/node", b)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
server := api.RunServer(true)
server.ServeHTTP(recorder, request)
c.Assert(recorder.Code, check.Equals, http.StatusOK)
nodes, err := mainDockerProvisioner.getCluster().Nodes()
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Metadata, check.DeepEquals, map[string]string{
"m2": "v9",
"m3": "v8",
})
}
func (s *S) SetUpTest(c *check.C) {
config.Set("database:url", "127.0.0.1:27017")
config.Set("database:name", "tsuru_events_migrate_tests")
conn, err := db.Conn()
c.Assert(err, check.IsNil)
defer conn.Close()
err = dbtest.ClearAllCollections(conn.Events().Database)
c.Assert(err, check.IsNil)
config.Set("routers:fake:type", "fake")
err = (&app.Plan{Name: "default", Router: "fake", CpuShare: 100, Default: true}).Save()
c.Assert(err, check.IsNil)
nativeScheme := auth.ManagedScheme(native.NativeScheme{})
app.AuthScheme = nativeScheme
s.user = &auth.User{Email: "*****@*****.**", Password: "******"}
_, err = nativeScheme.Create(s.user)
c.Assert(err, check.IsNil)
s.team = &auth.Team{Name: "angra"}
err = conn.Teams().Insert(s.team)
c.Assert(err, check.IsNil)
provision.DefaultProvisioner = "fake"
provisiontest.ProvisionerInstance.Reset()
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
}
func (s *S) TestPoolListPublicPool(c *check.C) {
pool := provision.Pool{Name: "pool1", Public: true}
opts := provision.AddPoolOptions{Name: pool.Name, Public: pool.Public}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
defaultPools, err := provision.ListPools(bson.M{"default": true})
c.Assert(err, check.IsNil)
expected := []provision.Pool{
defaultPools[0],
{Name: "pool1", Public: true, Teams: []string{}},
}
token := userWithPermission(c, permission.Permission{
Scheme: permission.PermTeamCreate,
Context: permission.Context(permission.CtxGlobal, ""),
})
req, err := http.NewRequest("GET", "/pools", nil)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = poolList(rec, req, token)
c.Assert(err, check.IsNil)
var pools []provision.Pool
err = json.NewDecoder(rec.Body).Decode(&pools)
c.Assert(err, check.IsNil)
c.Assert(pools, check.DeepEquals, expected)
}
func (s *HandlersSuite) TestAddNodeHandlerCreatingAnIaasMachineExplicit(c *check.C) {
server, waitQueue := s.startFakeDockerNode(c)
defer server.Stop()
iaas.RegisterIaasProvider("test-iaas", newTestIaaS)
iaas.RegisterIaasProvider("another-test-iaas", newTestIaaS)
mainDockerProvisioner.cluster, _ = cluster.New(&segregatedScheduler{}, &cluster.MapStorage{})
opts := provision.AddPoolOptions{Name: "pool1"}
err := provision.AddPool(opts)
defer provision.RemovePool("pool1")
b := bytes.NewBufferString(`{"pool": "pool1", "id": "test1", "iaas": "another-test-iaas"}`)
req, err := http.NewRequest("POST", "/docker/node?register=false", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = addNodeHandler(rec, req, nil)
c.Assert(err, check.IsNil)
waitQueue()
nodes, err := mainDockerProvisioner.getCluster().Nodes()
c.Assert(err, check.IsNil)
c.Assert(nodes, check.HasLen, 1)
c.Assert(nodes[0].Address, check.Equals, strings.TrimRight(server.URL(), "/"))
c.Assert(nodes[0].Metadata, check.DeepEquals, map[string]string{
"id": "test1",
"pool": "pool1",
"iaas": "another-test-iaas",
"iaas-id": "test1",
})
}
func (s *S) TestSchedulerScheduleByTeamOwner(c *check.C) {
a1 := app.App{Name: "impius", Teams: []string{}, TeamOwner: "tsuruteam"}
cont1 := container.Container{ID: "1", Name: "impius1", AppName: a1.Name}
err := s.storage.Apps().Insert(a1)
c.Assert(err, check.IsNil)
defer s.storage.Apps().RemoveAll(bson.M{"name": a1.Name})
p := provision.Pool{Name: "pool1", Teams: []string{"tsuruteam"}}
o := provision.AddPoolOptions{Name: p.Name}
err = provision.AddPool(o)
c.Assert(err, check.IsNil)
defer provision.RemovePool(p.Name)
err = provision.AddTeamsToPool(p.Name, p.Teams)
c.Assert(err, check.IsNil)
contColl := s.p.Collection()
defer contColl.Close()
err = contColl.Insert(cont1)
c.Assert(err, check.IsNil)
defer contColl.RemoveAll(bson.M{"name": cont1.Name})
scheduler := segregatedScheduler{provisioner: s.p}
clusterInstance, err := cluster.New(&scheduler, &cluster.MapStorage{})
s.p.cluster = clusterInstance
c.Assert(err, check.IsNil)
err = clusterInstance.Register(cluster.Node{
Address: s.server.URL(),
Metadata: map[string]string{"pool": "pool1"},
})
c.Assert(err, check.IsNil)
opts := docker.CreateContainerOptions{Name: cont1.Name}
node, err := scheduler.Schedule(clusterInstance, opts, []string{a1.Name, "web"})
c.Assert(err, check.IsNil)
c.Check(node.Address, check.Equals, s.server.URL())
}
func (s *S) SetUpTest(c *check.C) {
s.provisioner.Reset()
repositorytest.Reset()
dbtest.ClearAllCollections(s.conn.Apps().Database)
s.createUserAndTeam(c)
platform := Platform{Name: "python"}
s.conn.Platforms().Insert(platform)
s.defaultPlan = Plan{
Name: "default-plan",
Memory: 1024,
Swap: 1024,
CpuShare: 100,
Default: true,
}
err := s.conn.Plans().Insert(s.defaultPlan)
c.Assert(err, check.IsNil)
s.Pool = "pool1"
opts := provision.AddPoolOptions{Name: s.Pool}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
repository.Manager().CreateUser(s.user.Email)
factory, err := queue.Factory()
c.Assert(err, check.IsNil)
factory.Reset()
}
func (s *S) TestRebalanceContainersByHost(c *check.C) {
otherServer, err := dtesting.NewServer("localhost:0", nil, nil)
c.Assert(err, check.IsNil)
defer otherServer.Stop()
otherUrl := strings.Replace(otherServer.URL(), "127.0.0.1", "localhost", 1)
p := &dockerProvisioner{}
err = p.Initialize()
c.Assert(err, check.IsNil)
p.storage = &cluster.MapStorage{}
p.scheduler = &segregatedScheduler{provisioner: p}
p.cluster, err = cluster.New(p.scheduler, p.storage,
cluster.Node{Address: s.server.URL(), Metadata: map[string]string{"pool": "pool1"}},
cluster.Node{Address: otherUrl, Metadata: map[string]string{"pool": "pool1"}},
)
c.Assert(err, check.IsNil)
opts := provision.AddPoolOptions{Name: "pool1"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
err = provision.AddTeamsToPool("pool1", []string{"team1"})
c.Assert(err, check.IsNil)
err = s.newFakeImage(p, "tsuru/app-myapp", nil)
c.Assert(err, check.IsNil)
appInstance := provisiontest.NewFakeApp("myapp", "python", 0)
defer p.Destroy(appInstance)
p.Provision(appInstance)
imageId, err := appCurrentImageName(appInstance.GetName())
c.Assert(err, check.IsNil)
_, err = addContainersWithHost(&changeUnitsPipelineArgs{
toHost: "localhost",
toAdd: map[string]*containersToAdd{"web": {Quantity: 5}},
app: appInstance,
imageId: imageId,
provisioner: p,
})
c.Assert(err, check.IsNil)
appStruct := &app.App{
Name: appInstance.GetName(),
TeamOwner: "team1",
Pool: "pool1",
}
err = s.storage.Apps().Insert(appStruct)
c.Assert(err, check.IsNil)
c1, err := p.listContainersByHost("localhost")
c.Assert(err, check.IsNil)
c.Assert(c1, check.HasLen, 5)
c2, err := p.listContainersByHost("127.0.0.1")
c.Assert(err, check.IsNil)
c.Assert(c2, check.HasLen, 0)
err = p.Cluster().Unregister(otherUrl)
c.Assert(err, check.IsNil)
buf := safe.NewBuffer(nil)
err = p.rebalanceContainersByHost(net.URLToHost(otherUrl), buf)
c.Assert(err, check.IsNil)
c.Assert(p.scheduler.ignoredContainers, check.IsNil)
c2, err = p.listContainersByHost("127.0.0.1")
c.Assert(err, check.IsNil)
c.Assert(c2, check.HasLen, 5)
}
func (s *S) TestSchedulerSchedule(c *check.C) {
a1 := app.App{Name: "impius", Teams: []string{"tsuruteam", "nodockerforme"}, Pool: "pool1"}
a2 := app.App{Name: "mirror", Teams: []string{"tsuruteam"}, Pool: "pool1"}
a3 := app.App{Name: "dedication", Teams: []string{"nodockerforme"}, Pool: "pool1"}
cont1 := container.Container{ID: "1", Name: "impius1", AppName: a1.Name}
cont2 := container.Container{ID: "2", Name: "mirror1", AppName: a2.Name}
cont3 := container.Container{ID: "3", Name: "dedication1", AppName: a3.Name}
err := s.storage.Apps().Insert(a1, a2, a3)
c.Assert(err, check.IsNil)
defer s.storage.Apps().RemoveAll(bson.M{"name": bson.M{"$in": []string{a1.Name, a2.Name, a3.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)
c.Assert(err, check.IsNil)
defer provision.RemovePool(p.Name)
contColl := s.p.Collection()
defer contColl.Close()
err = contColl.Insert(
cont1, cont2, cont3,
)
c.Assert(err, check.IsNil)
defer contColl.RemoveAll(bson.M{"name": bson.M{"$in": []string{cont1.Name, cont2.Name, cont3.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("localhost:0", nil, nil)
c.Assert(err, check.IsNil)
defer server2.Stop()
err = clusterInstance.Register(cluster.Node{
Address: server1.URL(),
Metadata: map[string]string{"pool": "pool1"},
})
c.Assert(err, check.IsNil)
localURL := strings.Replace(server2.URL(), "127.0.0.1", "localhost", -1)
err = clusterInstance.Register(cluster.Node{
Address: localURL,
Metadata: map[string]string{"pool": "pool1"},
})
c.Assert(err, check.IsNil)
opts := docker.CreateContainerOptions{Name: cont1.Name}
node, err := scheduler.Schedule(clusterInstance, opts, &container.SchedulerOpts{AppName: a1.Name, ProcessName: "web"})
c.Assert(err, check.IsNil)
c.Check(node.Address, check.Equals, server1.URL())
opts = docker.CreateContainerOptions{Name: cont2.Name}
node, err = scheduler.Schedule(clusterInstance, opts, &container.SchedulerOpts{AppName: a2.Name, ProcessName: "web"})
c.Assert(err, check.IsNil)
c.Check(node.Address, check.Equals, localURL)
}
func (s *S) TestGetRemovableContainer(c *check.C) {
a1 := app.App{Name: "impius", Teams: []string{"tsuruteam", "nodockerforme"}, Pool: "pool1"}
cont1 := container{ID: "1", Name: "impius1", AppName: a1.Name, ProcessName: "web"}
cont2 := container{ID: "2", Name: "mirror1", AppName: a1.Name, ProcessName: "worker"}
a2 := app.App{Name: "notimpius", Teams: []string{"tsuruteam", "nodockerforme"}, Pool: "pool1"}
cont3 := container{ID: "3", Name: "dedication1", AppName: a2.Name, ProcessName: "web"}
cont4 := 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)
_, err = clusterInstance.Register("http://url0:1234", map[string]string{"pool": "pool1"})
c.Assert(err, check.IsNil)
_, err = clusterInstance.Register("http://url1:1234", 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 *ConsumptionSuite) TestRemoveServiceHandlerWIthAssociatedAppsWithNoUnbindAllListAllApp(c *check.C) {
var called int32
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == "DELETE" && r.URL.Path == "/resources/my-mysql/bind" {
atomic.StoreInt32(&called, 1)
}
}))
defer ts.Close()
srvc := service.Service{Name: "mysql", Endpoint: map[string]string{"production": ts.URL}}
err := srvc.Create()
c.Assert(err, check.IsNil)
defer s.conn.Services().Remove(bson.M{"_id": "mysql"})
p := app.Platform{Name: "zend"}
s.conn.Platforms().Insert(p)
s.pool = "test1"
opts := provision.AddPoolOptions{Name: "test1", Default: true}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
a := app.App{
Name: "app",
Platform: "zend",
TeamOwner: s.team.Name,
}
ab := app.App{
Name: "app2",
Platform: "zend",
TeamOwner: s.team.Name,
}
err = app.CreateApp(&a, s.user)
c.Assert(err, check.IsNil)
err = app.CreateApp(&ab, s.user)
c.Assert(err, check.IsNil)
units, _ := s.provisioner.AddUnits(&a, 1, "web", nil)
units, _ = s.provisioner.AddUnits(&ab, 1, "web", nil)
instance := service.ServiceInstance{
Name: "my-mysql",
ServiceName: "mysql",
Teams: []string{s.team.Name},
Apps: []string{"app", "app2"},
Units: []string{units[0].ID},
}
err = instance.Create()
c.Assert(err, check.IsNil)
defer s.conn.ServiceInstances().Remove(bson.M{"name": "my-mysql"})
recorder, request := makeRequestToRemoveInstanceHandlerWithNoUnbind("mysql", "my-mysql", c)
err = removeServiceInstance(recorder, request, s.token)
c.Assert(err, check.IsNil)
b, err := ioutil.ReadAll(recorder.Body)
c.Assert(err, check.IsNil)
var msg io.SimpleJsonMessage
json.Unmarshal(b, &msg)
c.Assert(msg.Error, check.Equals, service.ErrServiceInstanceBound.Error())
expectedMsg := "app,app2"
c.Assert(msg.Message, check.Equals, expectedMsg)
}
func (s *S) TestPoolUpdateOverwriteDefaultPoolHandler(c *check.C) {
provision.RemovePool("test1")
opts := provision.AddPoolOptions{Name: "pool1", Default: true}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
opts = provision.AddPoolOptions{Name: "pool2"}
err = provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool2")
b := bytes.NewBufferString(`{"default": true}`)
req, err := http.NewRequest("POST", "/pool/pool1?:name=pool2&force=true", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = poolUpdateHandler(rec, req, s.token)
c.Assert(err, check.IsNil)
p, err := provision.ListPools(bson.M{"_id": "pool2"})
c.Assert(err, check.IsNil)
c.Assert(p[0].Default, check.Equals, true)
}