func (s *S) TestAddPool(c *check.C) {
b := bytes.NewBufferString("name=pool1")
req, err := http.NewRequest("POST", "/pools", 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()
defer provision.RemovePool("pool1")
m := RunServer(true)
m.ServeHTTP(rec, req)
c.Assert(rec.Code, check.Equals, http.StatusCreated)
c.Assert(err, check.IsNil)
pools, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(pools, check.HasLen, 1)
b = bytes.NewBufferString("name=pool2&public=true")
req, err = http.NewRequest("POST", "/pools", 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()
defer provision.RemovePool("pool2")
m.ServeHTTP(rec, req)
c.Assert(rec.Code, check.Equals, http.StatusCreated)
pools, err = provision.ListPools(bson.M{"_id": "pool2"})
c.Assert(err, check.IsNil)
c.Assert(pools[0].Public, check.Equals, true)
}
func listPoolsToUser(w http.ResponseWriter, r *http.Request, t auth.Token) error {
u, err := t.User()
if err != nil {
return err
}
rec.Log(u.Email, "pool-list")
teams, err := u.Teams()
if err != nil {
return err
}
var poolsByTeam []PoolsByTeam
for _, t := range teams {
pools, err := provision.ListPools(bson.M{"teams": t.Name})
if err != nil {
return err
}
pbt := PoolsByTeam{Team: t.Name, Pools: provision.GetPoolsNames(pools)}
poolsByTeam = append(poolsByTeam, pbt)
}
publicPools, err := provision.ListPools(bson.M{"public": true})
if err != nil {
return err
}
p := map[string]interface{}{
"pools_by_team": poolsByTeam,
"public_pools": publicPools,
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(p)
}
func listPoolsToUser(w http.ResponseWriter, r *http.Request, t auth.Token) error {
u, err := t.User()
if err != nil {
return err
}
rec.Log(u.Email, "pool-list")
teams := []string{}
contexts := permission.ContextsForPermission(t, permission.PermAppCreate)
for _, c := range contexts {
if c.CtxType == permission.CtxGlobal {
teams = nil
break
}
if c.CtxType != permission.CtxTeam {
continue
}
teams = append(teams, c.Value)
}
var filter bson.M
if teams != nil {
filter = bson.M{"teams": bson.M{"$in": teams}}
}
pools, err := provision.ListPools(filter)
if err != nil {
return err
}
poolsByTeam := []PoolsByTeam{}
poolsByTeamMap := map[string]*PoolsByTeam{}
for _, p := range pools {
for _, t := range p.Teams {
if poolsByTeamMap[t] == nil {
poolsByTeam = append(poolsByTeam, PoolsByTeam{Team: t})
poolsByTeamMap[t] = &poolsByTeam[len(poolsByTeam)-1]
}
poolsByTeamMap[t].Pools = append(poolsByTeamMap[t].Pools, p.Name)
}
}
publicPools, err := provision.ListPools(bson.M{"public": true})
if err != nil {
return err
}
allowedDefault := permission.Check(t, permission.PermPoolUpdate)
defaultPool := []provision.Pool{}
if allowedDefault {
defaultPool, err = provision.ListPools(bson.M{"default": true})
if err != nil {
return err
}
}
p := map[string]interface{}{
"pools_by_team": poolsByTeam,
"public_pools": publicPools,
"default_pool": defaultPool,
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(p)
}
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 listPoolHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
pools, err := provision.ListPools(nil)
if err != nil {
return err
}
return json.NewEncoder(w).Encode(pools)
}
func (app *App) GetPoolForApp(poolName string) (string, error) {
var query bson.M
var poolTeam bool
if poolName != "" {
query = bson.M{"_id": poolName}
} else {
query = bson.M{"teams": app.TeamOwner}
}
pools, err := provision.ListPools(query)
if err != nil {
return "", err
}
if len(pools) > 1 {
return "", stderr.New("you have access to more than one pool, please choose one in app creation")
}
if len(pools) == 0 {
if poolName == "" {
return "", nil
}
return "", stderr.New("pool not found")
}
for _, team := range pools[0].Teams {
if team == app.TeamOwner {
poolTeam = true
break
}
}
if !pools[0].Public && !poolTeam {
return "", stderr.New(fmt.Sprintf("You don't have access to pool %s", poolName))
}
return pools[0].Name, nil
}
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 (app *App) GetDefaultPool() (string, error) {
pools, err := provision.ListPools(bson.M{"default": true})
if err != nil {
return "", err
}
if len(pools) == 0 {
return "", stderr.New("No default pool.")
}
return pools[0].Name, nil
}
func (app *App) GetFallbackPool() (string, error) {
query := bson.M{"$or": []bson.M{{"teams": bson.M{"$exists": false}}, {"teams": bson.M{"$size": 0}}}}
pools, err := provision.ListPools(query)
if err != nil {
return "", err
}
if len(pools) == 0 {
return "", stderr.New("No fallback pool.")
}
return pools[0].Name, nil
}
func (s *S) TestAddPoolHandler(c *check.C) {
b := bytes.NewBufferString(`{"name": "pool1"}`)
req, err := http.NewRequest("POST", "/pool", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
defer provision.RemovePool("pool1")
err = addPoolHandler(rec, req, nil)
c.Assert(err, check.IsNil)
pools, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(len(pools), check.Equals, 1)
}
func (p *dockerProvisioner) Nodes(app provision.App) ([]cluster.Node, error) {
pool := app.GetPool()
var (
pools []provision.Pool
err error
)
if pool == "" {
pools, err = provision.ListPools(bson.M{"$or": []bson.M{{"teams": app.GetTeamOwner()}, {"teams": bson.M{"$in": app.GetTeamsName()}}}})
} else {
pools, err = provision.ListPools(bson.M{"_id": pool})
}
if err != nil {
return nil, err
}
if len(pools) == 0 {
query := bson.M{"default": true}
pools, err = provision.ListPools(query)
if err != nil {
return nil, err
}
}
if len(pools) == 0 {
return nil, errNoDefaultPool
}
for _, pool := range pools {
nodes, err := p.Cluster().NodesForMetadata(map[string]string{"pool": pool.Name})
if err != nil {
return nil, errNoDefaultPool
}
if len(nodes) > 0 {
return nodes, nil
}
}
var nameList []string
for _, pool := range pools {
nameList = append(nameList, pool.Name)
}
poolsStr := strings.Join(nameList, ", pool=")
return nil, fmt.Errorf("No nodes found with one of the following metadata: pool=%s", poolsStr)
}
func (s *S) TestAddPoolHandler(c *check.C) {
b := bytes.NewBufferString(`{"name": "pool1"}`)
req, err := http.NewRequest("POST", "/pool", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
defer provision.RemovePool("pool1")
err = addPoolHandler(rec, req, s.token)
c.Assert(err, check.IsNil)
pools, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(pools, check.HasLen, 1)
b = bytes.NewBufferString(`{"name": "pool2", "public": true}`)
req, err = http.NewRequest("POST", "/pool", b)
c.Assert(err, check.IsNil)
rec = httptest.NewRecorder()
defer provision.RemovePool("pool2")
err = addPoolHandler(rec, req, s.token)
c.Assert(err, check.IsNil)
pools, err = provision.ListPools(bson.M{"_id": "pool2"})
c.Assert(err, check.IsNil)
c.Assert(pools[0].Public, check.Equals, true)
}
func (s *S) TestRemovePoolHandler(c *check.C) {
err := provision.AddPool("pool1", false)
c.Assert(err, check.IsNil)
b := bytes.NewBufferString(`{"pool": "pool1"}`)
req, err := http.NewRequest("DELETE", "/pool", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = removePoolHandler(rec, req, nil)
c.Assert(err, check.IsNil)
p, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(len(p), check.Equals, 0)
}
func (s *S) TestPoolUpdateToPublicHandler(c *check.C) {
opts := provision.AddPoolOptions{Name: "pool1"}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
b := bytes.NewBufferString(`{"public": true}`)
req, err := http.NewRequest("POST", "/pool/pool1?:name=pool1", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = poolUpdateHandler(rec, req, nil)
c.Assert(err, check.IsNil)
p, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(p[0].Public, check.Equals, true)
}
func (s *S) TestAddTeamsToPoolHandler(c *check.C) {
pool := provision.Pool{Name: "pool1"}
err := provision.AddPool(pool.Name, false)
c.Assert(err, check.IsNil)
defer provision.RemovePool(pool.Name)
b := bytes.NewBufferString(`{"pool": "pool1", "teams": ["test"]}`)
req, err := http.NewRequest("POST", "/pool/team", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = addTeamToPoolHandler(rec, req, nil)
c.Assert(err, check.IsNil)
p, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(p[0].Teams, check.DeepEquals, []string{"test"})
}
func (s *S) TestRemovePoolHandler(c *check.C) {
opts := provision.AddPoolOptions{
Name: "pool1",
}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
b := bytes.NewBufferString(`{"pool": "pool1"}`)
req, err := http.NewRequest("DELETE", "/pool", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = removePoolHandler(rec, req, s.token)
c.Assert(err, check.IsNil)
p, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(p, check.HasLen, 0)
}
func (s *S) TestRemovePoolHandler(c *check.C) {
opts := provision.AddPoolOptions{
Name: "pool1",
}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
req, err := http.NewRequest("DELETE", "/pools/pool1", 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)
p, err := provision.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(p, check.HasLen, 0)
}
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)
b := bytes.NewBufferString(`{"pool": "pool1", "teams": ["test"]}`)
req, err := http.NewRequest("DELETE", "/pool/pool1/team?:name=pool1", b)
c.Assert(err, check.IsNil)
rec := httptest.NewRecorder()
err = removeTeamToPoolHandler(rec, req, nil)
c.Assert(err, check.IsNil)
p, err := provision.ListPools(nil)
c.Assert(err, check.IsNil)
c.Assert(p[0].Teams, check.DeepEquals, []string{})
}
func (s *S) TestPoolUpdateToPublicHandler(c *check.C) {
opts := provision.AddPoolOptions{Name: "pool1"}
err := provision.AddPool(opts)
c.Assert(err, check.IsNil)
defer provision.RemovePool("pool1")
b := bytes.NewBufferString("public=true")
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.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(p[0].Public, check.Equals, true)
}
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.ListPools(bson.M{"_id": "pool1"})
c.Assert(err, check.IsNil)
c.Assert(p[0].Teams, check.DeepEquals, []string{"test"})
}
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)
}
func (s *HandlersSuite) SetUpSuite(c *check.C) {
config.Set("database:name", "docker_provision_handlers_tests_s")
config.Set("docker:collection", "docker_handler_suite")
config.Set("docker:run-cmd:port", 8888)
config.Set("docker:router", "fake")
config.Set("docker:cluster:mongo-url", "127.0.0.1:27017")
config.Set("docker:cluster:mongo-database", "docker_provision_handlers_tests_cluster_stor")
config.Set("docker:repository-namespace", "tsuru")
config.Set("queue:mongo-url", "127.0.0.1:27017")
config.Set("queue:mongo-database", "queue_provision_docker_tests_handlers")
config.Set("iaas:default", "test-iaas")
config.Set("iaas:node-protocol", "http")
config.Set("iaas:node-port", 1234)
config.Set("admin-team", "admin")
config.Set("routers:fake:type", "fake")
var err error
s.conn, err = db.Conn()
c.Assert(err, check.IsNil)
clusterDbUrl, _ := config.GetString("docker:cluster:mongo-url")
s.clusterSess, err = mgo.Dial(clusterDbUrl)
c.Assert(err, check.IsNil)
pools, err := provision.ListPools(nil)
c.Assert(err, check.IsNil)
for _, pool := range pools {
err = provision.RemovePool(pool.Name)
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", Users: []string{s.user.Email}}
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 (app *App) GetPoolForApp(poolName string) (string, error) {
var query bson.M
if poolName != "" {
byTeamOwner := bson.M{"$and": []bson.M{{"_id": poolName}, {"teams": app.TeamOwner}}}
publicPool := bson.M{"$and": []bson.M{{"_id": poolName}, {"public": true}}}
query = bson.M{"$or": []bson.M{byTeamOwner, publicPool}}
} else {
query = bson.M{"teams": app.TeamOwner}
}
pools, err := provision.ListPools(query)
if err != nil {
return "", err
}
if len(pools) > 1 {
return "", ManyPoolsError
}
if len(pools) == 0 && poolName != "" {
return "", stderr.New(fmt.Sprintf("You don't have access to pool %s", poolName))
}
if len(pools) == 0 {
return "", nil
}
return pools[0].Name, nil
}