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, "")
}