func addPlan(w http.ResponseWriter, r *http.Request, t auth.Token) error { var plan app.Plan err := json.NewDecoder(r.Body).Decode(&plan) if err != nil { return &errors.HTTP{ Code: http.StatusBadRequest, Message: "unable to parse request body", } } err = plan.Save() if _, ok := err.(app.PlanValidationError); ok { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == app.ErrPlanAlreadyExists { return &errors.HTTP{ Code: http.StatusConflict, Message: err.Error(), } } if err == nil { w.WriteHeader(http.StatusCreated) } return err }
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) }
// title: plan create // path: /plans // method: POST // consume: application/x-www-form-urlencoded // responses: // 201: Plan created // 400: Invalid data // 401: Unauthorized // 409: Plan already exists func addPlan(w http.ResponseWriter, r *http.Request, t auth.Token) (err error) { cpuShare, _ := strconv.Atoi(r.FormValue("cpushare")) isDefault, _ := strconv.ParseBool(r.FormValue("default")) memory := getSize(r.FormValue("memory")) swap := getSize(r.FormValue("swap")) plan := app.Plan{ Name: r.FormValue("name"), Memory: memory, Swap: swap, CpuShare: cpuShare, Default: isDefault, Router: r.FormValue("router"), } allowed := permission.Check(t, permission.PermPlanCreate) if !allowed { return permission.ErrUnauthorized } evt, err := event.New(&event.Opts{ Target: event.Target{Type: event.TargetTypePlan, Value: plan.Name}, Kind: permission.PermPlanCreate, Owner: t, CustomData: event.FormToCustomData(r.Form), Allowed: event.Allowed(permission.PermPlanReadEvents), }) if err != nil { return err } defer func() { evt.Done(err) }() err = plan.Save() if _, ok := err.(app.PlanValidationError); ok { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == app.ErrPlanAlreadyExists { return &errors.HTTP{ Code: http.StatusConflict, Message: err.Error(), } } if err == app.ErrLimitOfMemory || err == app.ErrLimitOfCpuShare { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == nil { w.WriteHeader(http.StatusCreated) } return err }
func (s *S) TestChangePlanNotFound(c *check.C) { plan := app.Plan{Name: "superplan", Memory: 268435456, Swap: 268435456, CpuShare: 100} err := plan.Save() c.Assert(err, check.IsNil) defer app.PlanRemove(plan.Name) a := app.App{Name: "someapp", Platform: "zend", Teams: []string{s.team.Name}, Plan: plan} err = app.CreateApp(&a, s.user) c.Assert(err, check.IsNil) defer s.deleteApp(&a) defer s.logConn.Logs(a.Name).DropCollection() request, err := http.NewRequest("POST", "/apps/someapp/plan", strings.NewReader(`{"name":"hiperplan"}`)) c.Assert(err, check.IsNil) request.Header.Set("Authorization", "bearer "+s.token.GetValue()) recorder := httptest.NewRecorder() m := RunServer(true) m.ServeHTTP(recorder, request) c.Check(recorder.Code, check.Equals, http.StatusNotFound) c.Check(recorder.Body.String(), check.Equals, app.ErrPlanNotFound.Error()+"\n") }
func addPlan(w http.ResponseWriter, r *http.Request, t auth.Token) error { cpuShare, _ := strconv.Atoi(r.FormValue("cpushare")) isDefault, _ := strconv.ParseBool(r.FormValue("default")) memory := getSize(r.FormValue("memory")) swap := getSize(r.FormValue("swap")) plan := app.Plan{ Name: r.FormValue("name"), Memory: memory, Swap: swap, CpuShare: cpuShare, Default: isDefault, Router: r.FormValue("router"), } allowed := permission.Check(t, permission.PermPlanCreate) if !allowed { return permission.ErrUnauthorized } err := plan.Save() if _, ok := err.(app.PlanValidationError); ok { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == app.ErrPlanAlreadyExists { return &errors.HTTP{ Code: http.StatusConflict, Message: err.Error(), } } if err == app.ErrLimitOfMemory || err == app.ErrLimitOfCpuShare { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == nil { w.WriteHeader(http.StatusCreated) } return err }
func addPlan(w http.ResponseWriter, r *http.Request, t auth.Token) error { var plan app.Plan err := json.NewDecoder(r.Body).Decode(&plan) if err != nil { return &errors.HTTP{ Code: http.StatusBadRequest, Message: "unable to parse request body", } } allowed := permission.Check(t, permission.PermPlanCreate) if !allowed { return permission.ErrUnauthorized } err = plan.Save() if _, ok := err.(app.PlanValidationError); ok { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == app.ErrPlanAlreadyExists { return &errors.HTTP{ Code: http.StatusConflict, Message: err.Error(), } } if err == app.ErrLimitOfMemory || err == app.ErrLimitOfCpuShare { return &errors.HTTP{ Code: http.StatusBadRequest, Message: err.Error(), } } if err == nil { w.WriteHeader(http.StatusCreated) } return err }