Merge branch 'master' into 3782-large-job-logs
[arvados.git] / services / keepproxy / keepproxy_test.go
1 package main
2
3 import (
4         "git.curoverse.com/arvados.git/sdk/go/keepclient"
5         "git.curoverse.com/arvados.git/sdk/go/arvadosclient"
6         "crypto/md5"
7         "crypto/tls"
8         "fmt"
9         . "gopkg.in/check.v1"
10         "io"
11         "io/ioutil"
12         "log"
13         "net/http"
14         "net/url"
15         "os"
16         "os/exec"
17         "testing"
18         "time"
19 )
20
21 // Gocheck boilerplate
22 func Test(t *testing.T) {
23         TestingT(t)
24 }
25
26 // Gocheck boilerplate
27 var _ = Suite(&ServerRequiredSuite{})
28
29 // Tests that require the Keep server running
30 type ServerRequiredSuite struct{}
31
32 func pythonDir() string {
33         cwd, _ := os.Getwd()
34         return fmt.Sprintf("%s/../../sdk/python/tests", cwd)
35 }
36
37 func (s *ServerRequiredSuite) SetUpSuite(c *C) {
38         cwd, _ := os.Getwd()
39         defer os.Chdir(cwd)
40
41         os.Chdir(pythonDir())
42         {
43                 cmd := exec.Command("python", "run_test_server.py", "start")
44                 stderr, err := cmd.StderrPipe()
45                 if err != nil {
46                         log.Fatalf("Setting up stderr pipe: %s", err)
47                 }
48                 go io.Copy(os.Stderr, stderr)
49                 if err := cmd.Run(); err != nil {
50                         panic(fmt.Sprintf("'python run_test_server.py start' returned error %s", err))
51                 }
52         }
53         {
54                 cmd := exec.Command("python", "run_test_server.py", "start_keep")
55                 stderr, err := cmd.StderrPipe()
56                 if err != nil {
57                         log.Fatalf("Setting up stderr pipe: %s", err)
58                 }
59                 go io.Copy(os.Stderr, stderr)
60                 if err := cmd.Run(); err != nil {
61                         panic(fmt.Sprintf("'python run_test_server.py start_keep' returned error %s", err))
62                 }
63         }
64
65         os.Setenv("ARVADOS_API_HOST", "localhost:3000")
66         os.Setenv("ARVADOS_API_TOKEN", "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
67         os.Setenv("ARVADOS_API_HOST_INSECURE", "true")
68 }
69
70 func (s *ServerRequiredSuite) TearDownSuite(c *C) {
71         cwd, _ := os.Getwd()
72         defer os.Chdir(cwd)
73
74         os.Chdir(pythonDir())
75         exec.Command("python", "run_test_server.py", "stop_keep").Run()
76         exec.Command("python", "run_test_server.py", "stop").Run()
77 }
78
79 func setupProxyService() {
80
81         client := &http.Client{Transport: &http.Transport{
82                 TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}}
83
84         var req *http.Request
85         var err error
86         if req, err = http.NewRequest("POST", fmt.Sprintf("https://%s/arvados/v1/keep_services", os.Getenv("ARVADOS_API_HOST")), nil); err != nil {
87                 panic(err.Error())
88         }
89         req.Header.Add("Authorization", fmt.Sprintf("OAuth2 %s", os.Getenv("ARVADOS_API_TOKEN")))
90
91         reader, writer := io.Pipe()
92
93         req.Body = reader
94
95         go func() {
96                 data := url.Values{}
97                 data.Set("keep_service", `{
98   "service_host": "localhost",
99   "service_port": 29950,
100   "service_ssl_flag": false,
101   "service_type": "proxy"
102 }`)
103
104                 writer.Write([]byte(data.Encode()))
105                 writer.Close()
106         }()
107
108         var resp *http.Response
109         if resp, err = client.Do(req); err != nil {
110                 panic(err.Error())
111         }
112         if resp.StatusCode != 200 {
113                 panic(resp.Status)
114         }
115 }
116
117 func runProxy(c *C, args []string, token string, port int) keepclient.KeepClient {
118         os.Args = append(args, fmt.Sprintf("-listen=:%v", port))
119         os.Setenv("ARVADOS_API_TOKEN", "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
120
121         go main()
122         time.Sleep(100 * time.Millisecond)
123
124         os.Setenv("ARVADOS_KEEP_PROXY", fmt.Sprintf("http://localhost:%v", port))
125         os.Setenv("ARVADOS_API_TOKEN", token)
126         arv, err := arvadosclient.MakeArvadosClient()
127         kc, err := keepclient.MakeKeepClient(&arv)
128         c.Check(kc.Using_proxy, Equals, true)
129         c.Check(len(kc.ServiceRoots()), Equals, 1)
130         c.Check(kc.ServiceRoots()[0], Equals, fmt.Sprintf("http://localhost:%v", port))
131         c.Check(err, Equals, nil)
132         os.Setenv("ARVADOS_KEEP_PROXY", "")
133         log.Print("keepclient created")
134         return kc
135 }
136
137 func (s *ServerRequiredSuite) TestPutAskGet(c *C) {
138         log.Print("TestPutAndGet start")
139
140         os.Args = []string{"keepproxy", "-listen=:29950"}
141         os.Setenv("ARVADOS_API_TOKEN", "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h")
142         go main()
143         time.Sleep(100 * time.Millisecond)
144
145         setupProxyService()
146
147         os.Setenv("ARVADOS_EXTERNAL_CLIENT", "true")
148         arv, err := arvadosclient.MakeArvadosClient()
149         kc, err := keepclient.MakeKeepClient(&arv)
150         c.Check(kc.Arvados.External, Equals, true)
151         c.Check(kc.Using_proxy, Equals, true)
152         c.Check(len(kc.ServiceRoots()), Equals, 1)
153         c.Check(kc.ServiceRoots()[0], Equals, "http://localhost:29950")
154         c.Check(err, Equals, nil)
155         os.Setenv("ARVADOS_EXTERNAL_CLIENT", "")
156         log.Print("keepclient created")
157
158         defer listener.Close()
159
160         hash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
161         var hash2 string
162
163         {
164                 _, _, err := kc.Ask(hash)
165                 c.Check(err, Equals, keepclient.BlockNotFound)
166                 log.Print("Ask 1")
167         }
168
169         {
170                 var rep int
171                 var err error
172                 hash2, rep, err = kc.PutB([]byte("foo"))
173                 c.Check(hash2, Matches, fmt.Sprintf(`^%s\+3(\+.+)?$`, hash))
174                 c.Check(rep, Equals, 2)
175                 c.Check(err, Equals, nil)
176                 log.Print("PutB")
177         }
178
179         {
180                 blocklen, _, err := kc.Ask(hash2)
181                 c.Assert(err, Equals, nil)
182                 c.Check(blocklen, Equals, int64(3))
183                 log.Print("Ask 2")
184         }
185
186         {
187                 reader, blocklen, _, err := kc.Get(hash2)
188                 c.Assert(err, Equals, nil)
189                 all, err := ioutil.ReadAll(reader)
190                 c.Check(all, DeepEquals, []byte("foo"))
191                 c.Check(blocklen, Equals, int64(3))
192                 log.Print("Get")
193         }
194
195         log.Print("TestPutAndGet done")
196 }
197
198 func (s *ServerRequiredSuite) TestPutAskGetForbidden(c *C) {
199         log.Print("TestPutAndGet start")
200
201         kc := runProxy(c, []string{"keepproxy"}, "123abc", 29951)
202         defer listener.Close()
203
204         log.Print("keepclient created")
205
206         hash := fmt.Sprintf("%x", md5.Sum([]byte("bar")))
207
208         {
209                 _, _, err := kc.Ask(hash)
210                 c.Check(err, Equals, keepclient.BlockNotFound)
211                 log.Print("Ask 1")
212         }
213
214         {
215                 hash2, rep, err := kc.PutB([]byte("bar"))
216                 c.Check(hash2, Equals, "")
217                 c.Check(rep, Equals, 0)
218                 c.Check(err, Equals, keepclient.InsufficientReplicasError)
219                 log.Print("PutB")
220         }
221
222         {
223                 blocklen, _, err := kc.Ask(hash)
224                 c.Assert(err, Equals, keepclient.BlockNotFound)
225                 c.Check(blocklen, Equals, int64(0))
226                 log.Print("Ask 2")
227         }
228
229         {
230                 _, blocklen, _, err := kc.Get(hash)
231                 c.Assert(err, Equals, keepclient.BlockNotFound)
232                 c.Check(blocklen, Equals, int64(0))
233                 log.Print("Get")
234         }
235
236         log.Print("TestPutAndGetForbidden done")
237 }
238
239 func (s *ServerRequiredSuite) TestGetDisabled(c *C) {
240         log.Print("TestGetDisabled start")
241
242         kc := runProxy(c, []string{"keepproxy", "-no-get"}, "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h", 29952)
243         defer listener.Close()
244
245         hash := fmt.Sprintf("%x", md5.Sum([]byte("baz")))
246
247         {
248                 _, _, err := kc.Ask(hash)
249                 c.Check(err, Equals, keepclient.BlockNotFound)
250                 log.Print("Ask 1")
251         }
252
253         {
254                 hash2, rep, err := kc.PutB([]byte("baz"))
255                 c.Check(hash2, Matches, fmt.Sprintf(`^%s\+3(\+.+)?$`, hash))
256                 c.Check(rep, Equals, 2)
257                 c.Check(err, Equals, nil)
258                 log.Print("PutB")
259         }
260
261         {
262                 blocklen, _, err := kc.Ask(hash)
263                 c.Assert(err, Equals, keepclient.BlockNotFound)
264                 c.Check(blocklen, Equals, int64(0))
265                 log.Print("Ask 2")
266         }
267
268         {
269                 _, blocklen, _, err := kc.Get(hash)
270                 c.Assert(err, Equals, keepclient.BlockNotFound)
271                 c.Check(blocklen, Equals, int64(0))
272                 log.Print("Get")
273         }
274
275         log.Print("TestGetDisabled done")
276 }
277
278 func (s *ServerRequiredSuite) TestPutDisabled(c *C) {
279         log.Print("TestPutDisabled start")
280
281         kc := runProxy(c, []string{"keepproxy", "-no-put"}, "4axaw8zxe0qm22wa6urpp5nskcne8z88cvbupv653y1njyi05h", 29953)
282         defer listener.Close()
283
284         {
285                 hash2, rep, err := kc.PutB([]byte("quux"))
286                 c.Check(hash2, Equals, "")
287                 c.Check(rep, Equals, 0)
288                 c.Check(err, Equals, keepclient.InsufficientReplicasError)
289                 log.Print("PutB")
290         }
291
292         log.Print("TestPutDisabled done")
293 }