FilesExpand file tree

 master

/

docker_api_exec_test.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

183 lines (146 loc) · 5.95 KB

 master

/

docker_api_exec_test.go

Copy path

Top

File metadata and controls

• Code
• Blame

183 lines (146 loc) · 5.95 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

// +build !test_no_exec

package main

import (

"bytes"

"encoding/json"

"fmt"

"net/http"

"strings"

"time"

"github.com/docker/docker/pkg/integration/checker"

"github.com/go-check/check"

)

// Regression test for #9414

func (s *DockerSuite) TestExecApiCreateNoCmd(c *check.C) {

name := "exec_test"

dockerCmd(c, "run", "-d", "-t", "--name", name, "busybox", "/bin/sh")

status, body, err := sockRequest("POST", fmt.Sprintf("/containers/%s/exec", name), map[string]interface{}{"Cmd": nil})

c.Assert(err, checker.IsNil)

c.Assert(status, checker.Equals, http.StatusInternalServerError)

comment := check.Commentf("Expected message when creating exec command with no Cmd specified")

c.Assert(string(body), checker.Contains, "No exec command specified", comment)

}

func (s *DockerSuite) TestExecApiCreateNoValidContentType(c *check.C) {

name := "exec_test"

dockerCmd(c, "run", "-d", "-t", "--name", name, "busybox", "/bin/sh")

jsonData := bytes.NewBuffer(nil)

if err := json.NewEncoder(jsonData).Encode(map[string]interface{}{"Cmd": nil}); err != nil {

c.Fatalf("Can not encode data to json %s", err)

}

res, body, err := sockRequestRaw("POST", fmt.Sprintf("/containers/%s/exec", name), jsonData, "text/plain")

c.Assert(err, checker.IsNil)

c.Assert(res.StatusCode, checker.Equals, http.StatusInternalServerError)

b, err := readBody(body)

c.Assert(err, checker.IsNil)

comment := check.Commentf("Expected message when creating exec command with invalid Content-Type specified")

c.Assert(string(b), checker.Contains, "Content-Type specified", comment)

}

func (s *DockerSuite) TestExecApiCreateContainerPaused(c *check.C) {

// Not relevant on Windows as Windows containers cannot be paused

testRequires(c, DaemonIsLinux)

name := "exec_create_test"

dockerCmd(c, "run", "-d", "-t", "--name", name, "busybox", "/bin/sh")

dockerCmd(c, "pause", name)

status, body, err := sockRequest("POST", fmt.Sprintf("/containers/%s/exec", name), map[string]interface{}{"Cmd": []string{"true"}})

c.Assert(err, checker.IsNil)

c.Assert(status, checker.Equals, http.StatusConflict)

comment := check.Commentf("Expected message when creating exec command with Container %s is paused", name)

c.Assert(string(body), checker.Contains, "Container "+name+" is paused, unpause the container before exec", comment)

}

func (s *DockerSuite) TestExecApiStart(c *check.C) {

testRequires(c, DaemonIsLinux) // Uses pause/unpause but bits may be salvagable to Windows to Windows CI

dockerCmd(c, "run", "-d", "--name", "test", "busybox", "top")

id := createExec(c, "test")

startExec(c, id, http.StatusOK)

id = createExec(c, "test")

dockerCmd(c, "stop", "test")

startExec(c, id, http.StatusNotFound)

dockerCmd(c, "start", "test")

startExec(c, id, http.StatusNotFound)

// make sure exec is created before pausing

id = createExec(c, "test")

dockerCmd(c, "pause", "test")

startExec(c, id, http.StatusConflict)

dockerCmd(c, "unpause", "test")

startExec(c, id, http.StatusOK)

}

func (s *DockerSuite) TestExecApiStartBackwardsCompatible(c *check.C) {

runSleepingContainer(c, "-d", "--name", "test")

id := createExec(c, "test")

resp, body, err := sockRequestRaw("POST", fmt.Sprintf("/v1.20/exec/%s/start", id), strings.NewReader(`{"Detach": true}`), "text/plain")

c.Assert(err, checker.IsNil)

b, err := readBody(body)

comment := check.Commentf("response body: %s", b)

c.Assert(err, checker.IsNil, comment)

c.Assert(resp.StatusCode, checker.Equals, http.StatusOK, comment)

}

// #19362

func (s *DockerSuite) TestExecApiStartMultipleTimesError(c *check.C) {

runSleepingContainer(c, "-d", "--name", "test")

execID := createExec(c, "test")

startExec(c, execID, http.StatusOK)

timeout := time.After(60 * time.Second)

var execJSON struct{ Running bool }

for {

select {

case <-timeout:

c.Fatal("timeout waiting for exec to start")

default:

}

inspectExec(c, execID, &execJSON)

if !execJSON.Running {

break

}

}

startExec(c, execID, http.StatusConflict)

}

// #20638

func (s *DockerSuite) TestExecApiStartWithDetach(c *check.C) {

name := "foo"

runSleepingContainer(c, "-d", "-t", "--name", name)

data := map[string]interface{}{

"cmd": []string{"true"},

"AttachStdin": true,

}

_, b, err := sockRequest("POST", fmt.Sprintf("/containers/%s/exec", name), data)

c.Assert(err, checker.IsNil, check.Commentf(string(b)))

createResp := struct {

ID string `json:"Id"`

}{}

c.Assert(json.Unmarshal(b, &createResp), checker.IsNil, check.Commentf(string(b)))

_, body, err := sockRequestRaw("POST", fmt.Sprintf("/exec/%s/start", createResp.ID), strings.NewReader(`{"Detach": true}`), "application/json")

c.Assert(err, checker.IsNil)

b, err = readBody(body)

comment := check.Commentf("response body: %s", b)

c.Assert(err, checker.IsNil, comment)

resp, _, err := sockRequestRaw("GET", "/_ping", nil, "")

c.Assert(err, checker.IsNil)

if resp.StatusCode != http.StatusOK {

c.Fatal("daemon is down, it should alive")

}

}

func createExec(c *check.C, name string) string {

_, b, err := sockRequest("POST", fmt.Sprintf("/containers/%s/exec", name), map[string]interface{}{"Cmd": []string{"true"}})

c.Assert(err, checker.IsNil, check.Commentf(string(b)))

createResp := struct {

ID string `json:"Id"`

}{}

c.Assert(json.Unmarshal(b, &createResp), checker.IsNil, check.Commentf(string(b)))

return createResp.ID

}

func startExec(c *check.C, id string, code int) {

resp, body, err := sockRequestRaw("POST", fmt.Sprintf("/exec/%s/start", id), strings.NewReader(`{"Detach": true}`), "application/json")

c.Assert(err, checker.IsNil)

b, err := readBody(body)

comment := check.Commentf("response body: %s", b)

c.Assert(err, checker.IsNil, comment)

c.Assert(resp.StatusCode, checker.Equals, code, comment)

}

func inspectExec(c *check.C, id string, out interface{}) {

resp, body, err := sockRequestRaw("GET", fmt.Sprintf("/exec/%s/json", id), nil, "")

c.Assert(err, checker.IsNil)

defer body.Close()

c.Assert(resp.StatusCode, checker.Equals, http.StatusOK)

err = json.NewDecoder(body).Decode(out)

c.Assert(err, checker.IsNil)

}