FilesExpand file tree

client/v0.6.2

/

client_hook.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

70 lines (58 loc) · 1.38 KB

client/v0.6.2

/

client_hook.go

Copy path

Top

File metadata and controls

• Code
• Blame

70 lines (58 loc) · 1.38 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

package client

import (

"errors"

"io"

"net/http"

)

type hookTransport struct {

base http.RoundTripper

reqHooks []RequestHook

respHooks []ResponseHook

}

func (t *hookTransport) RoundTrip(req *http.Request) (*http.Response, error) {

if len(t.reqHooks) > 0 {

hookReq := req.Clone(req.Context())

if hookReq.Body != nil {

hookReq.Body = hookBody{}

}

if hookReq.GetBody != nil {

hookReq.GetBody = func() (io.ReadCloser, error) {

return hookBody{}, nil

}

}

for _, h := range t.reqHooks {

if err := h(hookReq); err != nil {

// The base transport never takes ownership, so close the original

// request body before returning the hook error.

if req.Body != nil {

_ = req.Body.Close()

}

return nil, err

}

}

// Restore the actual request body after the hooks have run. The

// modified request metadata is preserved on hookReq.

hookReq.Body = req.Body

hookReq.GetBody = req.GetBody

req = hookReq

}

resp, err := t.base.RoundTrip(req)

if err != nil {

return resp, err

}

if len(t.respHooks) > 0 {

hookResp := *resp

if hookResp.Body != nil {

hookResp.Body = hookBody{}

}

for _, h := range t.respHooks {

h(&hookResp)

}

}

return resp, nil

}

type hookBody struct{}

func (hookBody) Read([]byte) (int, error) {

return 0, errors.New("hooks must not read HTTP message body")

}

func (hookBody) Close() error { return nil }