func platformAdd(w http.ResponseWriter, r *http.Request, t auth.Token) error { defer r.Body.Close() name := r.FormValue("name") file, _, _ := r.FormFile("dockerfile_content") if file != nil { defer file.Close() } args := make(map[string]string) for key, values := range r.Form { args[key] = values[0] } canCreatePlatform := permission.Check(t, permission.PermPlatformCreate) if !canCreatePlatform { return permission.ErrUnauthorized } w.Header().Set("Content-Type", "text") keepAliveWriter := io.NewKeepAliveWriter(w, 30*time.Second, "") defer keepAliveWriter.Stop() writer := &io.SimpleJsonMessageEncoderWriter{Encoder: json.NewEncoder(keepAliveWriter)} err := app.PlatformAdd(provision.PlatformOptions{ Name: name, Args: args, Input: file, Output: writer, }) if err != nil { writer.Encode(io.SimpleJsonMessage{Error: err.Error()}) writer.Write([]byte("Failed to add platform!\n")) return nil } writer.Write([]byte("Platform successfully added!\n")) return nil }
func (s *PlatformSuite) TestPlatformUpdate(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) var buf bytes.Buffer dockerfileURL := "http://localhost/Dockerfile" writer := multipart.NewWriter(&buf) writer.WriteField("dockerfile", dockerfileURL) writer.Close() request, _ := http.NewRequest("PUT", "/platforms/wat", &buf) request.Header.Add("Content-Type", writer.FormDataContentType()) token := createToken(c) request.Header.Set("Authorization", "b "+token.GetValue()) recorder := httptest.NewRecorder() m := RunServer(true) m.ServeHTTP(recorder, request) var msg io.SimpleJsonMessage json.Unmarshal(recorder.Body.Bytes(), &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") c.Assert(recorder.Header().Get("Content-Type"), check.Equals, "application/x-json-stream") }
func (p *PlatformSuite) TestPlatformUpdate(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) var buf bytes.Buffer dockerfileURL := "http://localhost/Dockerfile" writer := multipart.NewWriter(&buf) writer.WriteField("dockerfile", dockerfileURL) writer.Close() request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat", &buf) request.Header.Add("Content-Type", writer.FormDataContentType()) recorder := httptest.NewRecorder() token := createToken(c) result := platformUpdate(recorder, request, token) c.Assert(result, check.IsNil) b, err := ioutil.ReadAll(recorder.Body) c.Assert(err, check.IsNil) var msg io.SimpleJsonMessage json.Unmarshal(b, &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") }
func (p *PlatformSuite) TestPlatformUpdateDisableFalseAndDockerfile(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) dockerfile_url := "http://localhost/Dockerfile" body := fmt.Sprintf("dockerfile=%s", dockerfile_url) request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat&disabled=false", strings.NewReader(body)) request.Header.Add("Content-Type", "multipart/form-data") recorder := httptest.NewRecorder() token := createToken(c) result := platformUpdate(recorder, request, token) c.Assert(result, check.IsNil) b, err := ioutil.ReadAll(recorder.Body) c.Assert(err, check.IsNil) var msg io.SimpleJsonMessage json.Unmarshal(b, &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") }
func (s *PlatformSuite) TestPlatformUpdateDisableTrueAndDockerfile(c *check.C) { err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) dockerfileURL := "http://localhost/Dockerfile" var buf bytes.Buffer writer := multipart.NewWriter(&buf) writer.WriteField("dockerfile", dockerfileURL) writer.WriteField("disabled", "true") writer.Close() request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat", &buf) request.Header.Add("Content-Type", writer.FormDataContentType()) recorder := httptest.NewRecorder() token := createToken(c) result := platformUpdate(recorder, request, token) c.Assert(result, check.IsNil) var msg io.SimpleJsonMessage json.Unmarshal(recorder.Body.Bytes(), &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") c.Assert(eventtest.EventDesc{ Target: event.Target{Type: event.TargetTypePlatform, Value: "wat"}, Owner: token.GetUserName(), Kind: "platform.update", StartCustomData: []map[string]interface{}{ {"name": ":name", "value": "wat"}, {"name": "disabled", "value": "true"}, {"name": "dockerfile", "value": dockerfileURL}, }, }, eventtest.HasEvent) }
func (s *PlatformSuite) TestPlatformUpdateOnlyDisableTrue(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) dockerfileURL := "" body := fmt.Sprintf("dockerfile=%s", dockerfileURL) request, err := http.NewRequest("PUT", "/platforms/wat?disabled=true", strings.NewReader(body)) c.Assert(err, check.IsNil) token := createToken(c) request.Header.Add("Authorization", "b "+token.GetValue()) request.Header.Add("Content-Type", "multipart/form-data") recorder := httptest.NewRecorder() m := RunServer(true) m.ServeHTTP(recorder, request) c.Assert(recorder.Code, check.Equals, http.StatusOK) c.Assert(recorder.Header().Get("Content-Type"), check.Equals, "application/x-json-stream") var msg io.SimpleJsonMessage json.Unmarshal(recorder.Body.Bytes(), &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") }
func (s *PlatformSuite) TestPlatformUpdateOnlyDisableTrue(c *check.C) { err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) var buf bytes.Buffer writer := multipart.NewWriter(&buf) writer.WriteField("dockerfile", "") writer.WriteField("disabled", "true") writer.Close() request, err := http.NewRequest("PUT", "/platforms/wat", &buf) c.Assert(err, check.IsNil) token := createToken(c) request.Header.Add("Authorization", "b "+token.GetValue()) request.Header.Add("Content-Type", writer.FormDataContentType()) recorder := httptest.NewRecorder() m := RunServer(true) m.ServeHTTP(recorder, request) c.Assert(recorder.Code, check.Equals, http.StatusOK) c.Assert(recorder.Header().Get("Content-Type"), check.Equals, "application/x-json-stream") var msg io.SimpleJsonMessage json.Unmarshal(recorder.Body.Bytes(), &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") c.Assert(eventtest.EventDesc{ Target: event.Target{Type: event.TargetTypePlatform, Value: "wat"}, Owner: token.GetUserName(), Kind: "platform.update", StartCustomData: []map[string]interface{}{ {"name": ":name", "value": "wat"}, {"name": "disabled", "value": "true"}, }, }, eventtest.HasEvent) }
func platformAdd(w http.ResponseWriter, r *http.Request, t auth.Token) error { name := r.FormValue("name") args := make(map[string]string) for key, values := range r.Form { args[key] = values[0] } w.Header().Set("Content-Type", "text") return app.PlatformAdd(name, args, w) }
func platformAdd(w http.ResponseWriter, r *http.Request, t *auth.Token) error { name := r.FormValue("name") dockerfile := r.FormValue("dockerfile") err := app.PlatformAdd(name, dockerfile) if err != nil { return err } return nil }
func platformAdd(w http.ResponseWriter, r *http.Request, t auth.Token) error { name := r.FormValue("name") args := make(map[string]string) for key, values := range r.Form { args[key] = values[0] } w.Header().Set("Content-Type", "text") writer := io.NewKeepAliveWriter(w, 30*time.Second, "please wait...") err := app.PlatformAdd(name, args, writer) if err != nil { return err } fmt.Fprintln(w, "\nOK!") return nil }
func (p *PlatformSuite) TestPlatformRemove(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd("test", nil, nil) c.Assert(err, check.IsNil) request, _ := http.NewRequest("DELETE", "/platforms/test?:name=test", nil) recorder := httptest.NewRecorder() err = platformRemove(recorder, request, nil) c.Assert(err, check.IsNil) }
func (*PlatformSuite) TestPlatformRemove(c *check.C) { err := app.PlatformAdd(provision.PlatformOptions{Name: "test", Args: nil, Output: nil}) c.Assert(err, check.IsNil) request, _ := http.NewRequest("DELETE", "/platforms/test?:name=test", nil) recorder := httptest.NewRecorder() token := createToken(c) err = platformRemove(recorder, request, token) c.Assert(err, check.IsNil) c.Assert(eventtest.EventDesc{ Target: event.Target{Type: event.TargetTypePlatform, Value: "test"}, Owner: token.GetUserName(), Kind: "platform.delete", StartCustomData: []map[string]interface{}{ {"name": ":name", "value": "test"}, }, }, eventtest.HasEvent) }
func (p *PlatformSuite) TestPlatformRemove(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd(provision.PlatformOptions{Name: "test", Args: nil, Output: nil}) c.Assert(err, check.IsNil) request, _ := http.NewRequest("DELETE", "/platforms/test?:name=test", nil) recorder := httptest.NewRecorder() token := createToken(c) err = platformRemove(recorder, request, token) c.Assert(err, check.IsNil) }
func (p *PlatformSuite) TestPlatformUpdate(c *gocheck.C) { provisioner := testing.ExtensibleFakeProvisioner{ FakeProvisioner: testing.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd("wat", nil, nil) c.Assert(err, gocheck.IsNil) dockerfile_url := "http://localhost/Dockerfile" body := fmt.Sprintf("dockerfile=%s", dockerfile_url) request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat", strings.NewReader(body)) request.Header.Add("Content-Type", "application/x-www-form-urlencoded") recorder := httptest.NewRecorder() result := platformUpdate(recorder, request, nil) c.Assert(result, gocheck.IsNil) }
func (s *PlatformSuite) TestPlatformUpdateOnlyDisableFalse(c *check.C) { err := app.PlatformAdd(provision.PlatformOptions{Name: "wat", Args: nil, Output: nil}) c.Assert(err, check.IsNil) dockerfileURL := "" var buf bytes.Buffer writer := multipart.NewWriter(&buf) writer.WriteField("dockerfile", dockerfileURL) writer.WriteField("disabled", "false") writer.Close() request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat", &buf) request.Header.Add("Content-Type", writer.FormDataContentType()) recorder := httptest.NewRecorder() token := createToken(c) result := platformUpdate(recorder, request, token) c.Assert(result, check.IsNil) var msg io.SimpleJsonMessage json.Unmarshal(recorder.Body.Bytes(), &msg) c.Assert(msg.Error, check.Equals, "") }
// title: add platform // path: /platforms // method: POST // consume: multipart/form-data // produce: application/x-json-stream // responses: // 200: Platform created // 400: Invalid data // 401: Unauthorized func platformAdd(w http.ResponseWriter, r *http.Request, t auth.Token) (err error) { name := r.FormValue("name") file, _, _ := r.FormFile("dockerfile_content") if file != nil { defer file.Close() } args := make(map[string]string) for key, values := range r.Form { args[key] = values[0] } canCreatePlatform := permission.Check(t, permission.PermPlatformCreate) if !canCreatePlatform { return permission.ErrUnauthorized } w.Header().Set("Content-Type", "application/x-json-stream") keepAliveWriter := io.NewKeepAliveWriter(w, 30*time.Second, "") defer keepAliveWriter.Stop() writer := &io.SimpleJsonMessageEncoderWriter{Encoder: json.NewEncoder(keepAliveWriter)} evt, err := event.New(&event.Opts{ Target: event.Target{Type: event.TargetTypePlatform, Value: name}, Kind: permission.PermPlatformCreate, Owner: t, CustomData: event.FormToCustomData(r.Form), Allowed: event.Allowed(permission.PermPlatformReadEvents), }) if err != nil { return err } defer func() { evt.Done(err) }() err = app.PlatformAdd(provision.PlatformOptions{ Name: name, Args: args, Input: file, Output: writer, }) if err != nil { return err } writer.Write([]byte("Platform successfully added!\n")) return nil }
func (p *PlatformSuite) TestPlatformUpdateOnlyDisableTrue(c *check.C) { provisioner := provisiontest.ExtensibleFakeProvisioner{ FakeProvisioner: provisiontest.NewFakeProvisioner(), } oldProvisioner := app.Provisioner app.Provisioner = &provisioner defer func() { app.Provisioner = oldProvisioner }() err := app.PlatformAdd("wat", nil, nil) c.Assert(err, check.IsNil) dockerfile_url := "" body := fmt.Sprintf("dockerfile=%s", dockerfile_url) request, _ := http.NewRequest("PUT", "/platforms/wat?:name=wat&disabled=true", strings.NewReader(body)) request.Header.Add("Content-Type", "application/x-www-form-urlencoded") recorder := httptest.NewRecorder() result := platformUpdate(recorder, request, nil) c.Assert(result, check.IsNil) b, err := ioutil.ReadAll(recorder.Body) c.Assert(err, check.IsNil) var msg io.SimpleJsonMessage json.Unmarshal(b, &msg) c.Assert(errors.New(msg.Error), check.ErrorMatches, "") }