Debian Codegraph @

v5/transport.go

raw
1 package v5
2
3 import (
4 "bufio"
5 "bytes"
6 "encoding/json"
7 "errors"
8 "fmt"
9 "log"
10 "net/http"
11 "net/http/httputil"
12 "regexp"
13 "strings"
14
15 "github.com/pborman/uuid"
16 )
17
18 var DefaultTransport = &Transport{}
19
20 var DefaultClient = &http.Client{
21 Transport: DefaultTransport,
22 }
23
24 type Transport struct {
25 // Username is the HTTP basic auth username for API calls made by this Client.
26 Username string
27
28 // Password is the HTTP basic auth password for API calls made by this Client.
29 Password string
30
31 // BearerToken is a bearer token to authorize the request with. If this is
32 // set, the basic auth credentials will be ignored.
33 BearerToken string
34
35 // UserAgent to be provided in API requests. Set to DefaultUserAgent if not
36 // specified.
37 UserAgent string
38
39 // Debug mode can be used to dump the full request and response to stdout.
40 Debug bool
41
42 // AdditionalHeaders are extra headers to add to each HTTP request sent by
43 // this Client.
44 AdditionalHeaders http.Header
45
46 // Transport is the HTTP transport to use when making requests.
47 // It will default to http.DefaultTransport if nil.
48 Transport http.RoundTripper
49 }
50
51 // Forward CancelRequest to underlying Transport
52 func (t *Transport) CancelRequest(req *http.Request) {
53 type canceler interface {
54 CancelRequest(*http.Request)
55 }
56 tr, ok := t.Transport.(canceler)
57 if !ok {
58 log.Printf("heroku: Client Transport of type %T doesn't support CancelRequest; Timeout not supported\n", t.Transport)
59 return
60 }
61 tr.CancelRequest(req)
62 }
63
64 func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
65 if t.Transport == nil {
66 t.Transport = http.DefaultTransport
67 }
68
69 // Making a copy of the Request so that
70 // we don't modify the Request we were given.
71 req = cloneRequest(req)
72
73 if t.UserAgent != "" {
74 req.Header.Set("User-Agent", t.UserAgent)
75 }
76
77 req.Header.Set("Accept", "application/vnd.heroku+json; version=3")
78 req.Header.Set("Request-Id", uuid.New())
79
80 if t.BearerToken != "" {
81 req.Header.Add("Authorization", "Bearer "+t.BearerToken)
82 } else if t.Username != "" || t.Password != "" {
83 req.SetBasicAuth(t.Username, t.Password)
84 }
85
86 for k, v := range t.AdditionalHeaders {
87 req.Header[k] = v
88 }
89
90 if t.Debug {
91 dump, err := httputil.DumpRequestOut(req, true)
92 if err != nil {
93 log.Println(err)
94 } else {
95 scanner := bufio.NewScanner(bytes.NewReader(dump))
96 matcher := regexp.MustCompile(`(?i)authorization:`)
97 for scanner.Scan() {
98 line := scanner.Text()
99 if matcher.MatchString(line) {
100 matches := strings.Split(line, `:`)
101 line = fmt.Sprintf("%s: [redacted]", matches[0])
102 }
103 log.Println(line)
104 }
105 if err := scanner.Err(); err != nil {
106 log.Printf("Error scanning HTTP debug output for secret tokens: %s\n", err)
107 }
108 }
109 }
110
111 resp, err := t.Transport.RoundTrip(req)
112 if err != nil {
113 if resp != nil {
114 resp.Body.Close()
115 }
116 return nil, err
117 }
118
119 if t.Debug {
120 dump, err := httputil.DumpResponse(resp, true)
121 if err != nil {
122 log.Println(err)
123 } else {
124 log.Printf("%s", dump)
125 }
126 }
127
128 if err = checkResponse(resp); err != nil {
129 if resp != nil {
130 resp.Body.Close()
131 }
132 return nil, err
133 }
134
135 return resp, nil
136 }
137
138 type Error struct {
139 error
140 ID string
141 URL string
142 // StatusCode is the HTTP status code returned from the remote server.
143 StatusCode int
144 }
145
146 func checkResponse(resp *http.Response) error {
147 if resp.StatusCode/100 != 2 { // 200, 201, 202, etc
148 var e struct {
149 Message string
150 ID string
151 URL string `json:"url"`
152 }
153 err := json.NewDecoder(resp.Body).Decode(&e)
154 if err != nil {
155 return fmt.Errorf("encountered an error : %s", resp.Status)
156 }
157 return Error{error: errors.New(e.Message), ID: e.ID, URL: e.URL, StatusCode: resp.StatusCode}
158 }
159 if msg := resp.Header.Get("X-Heroku-Warning"); msg != "" {
160 log.Println(strings.TrimSpace(msg))
161 }
162 return nil
163 }
164
165 // cloneRequest returns a clone of the provided *http.Request.
166 func cloneRequest(req *http.Request) *http.Request {
167 // shallow copy of the struct
168 clone := new(http.Request)
169 *clone = *req
170 // deep copy of the Header
171 clone.Header = make(http.Header)
172 for k, s := range req.Header {
173 clone.Header[k] = s
174 }
175 return clone
176 }