diff options
Diffstat (limited to 'vendor/golang.org/x/oauth2/token.go')
-rw-r--r-- | vendor/golang.org/x/oauth2/token.go | 178 |
1 files changed, 178 insertions, 0 deletions
diff --git a/vendor/golang.org/x/oauth2/token.go b/vendor/golang.org/x/oauth2/token.go new file mode 100644 index 0000000..8227203 --- /dev/null +++ b/vendor/golang.org/x/oauth2/token.go | |||
@@ -0,0 +1,178 @@ | |||
1 | // Copyright 2014 The Go Authors. All rights reserved. | ||
2 | // Use of this source code is governed by a BSD-style | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package oauth2 | ||
6 | |||
7 | import ( | ||
8 | "context" | ||
9 | "fmt" | ||
10 | "net/http" | ||
11 | "net/url" | ||
12 | "strconv" | ||
13 | "strings" | ||
14 | "time" | ||
15 | |||
16 | "golang.org/x/oauth2/internal" | ||
17 | ) | ||
18 | |||
19 | // expiryDelta determines how earlier a token should be considered | ||
20 | // expired than its actual expiration time. It is used to avoid late | ||
21 | // expirations due to client-server time mismatches. | ||
22 | const expiryDelta = 10 * time.Second | ||
23 | |||
24 | // Token represents the credentials used to authorize | ||
25 | // the requests to access protected resources on the OAuth 2.0 | ||
26 | // provider's backend. | ||
27 | // | ||
28 | // Most users of this package should not access fields of Token | ||
29 | // directly. They're exported mostly for use by related packages | ||
30 | // implementing derivative OAuth2 flows. | ||
31 | type Token struct { | ||
32 | // AccessToken is the token that authorizes and authenticates | ||
33 | // the requests. | ||
34 | AccessToken string `json:"access_token"` | ||
35 | |||
36 | // TokenType is the type of token. | ||
37 | // The Type method returns either this or "Bearer", the default. | ||
38 | TokenType string `json:"token_type,omitempty"` | ||
39 | |||
40 | // RefreshToken is a token that's used by the application | ||
41 | // (as opposed to the user) to refresh the access token | ||
42 | // if it expires. | ||
43 | RefreshToken string `json:"refresh_token,omitempty"` | ||
44 | |||
45 | // Expiry is the optional expiration time of the access token. | ||
46 | // | ||
47 | // If zero, TokenSource implementations will reuse the same | ||
48 | // token forever and RefreshToken or equivalent | ||
49 | // mechanisms for that TokenSource will not be used. | ||
50 | Expiry time.Time `json:"expiry,omitempty"` | ||
51 | |||
52 | // raw optionally contains extra metadata from the server | ||
53 | // when updating a token. | ||
54 | raw interface{} | ||
55 | } | ||
56 | |||
57 | // Type returns t.TokenType if non-empty, else "Bearer". | ||
58 | func (t *Token) Type() string { | ||
59 | if strings.EqualFold(t.TokenType, "bearer") { | ||
60 | return "Bearer" | ||
61 | } | ||
62 | if strings.EqualFold(t.TokenType, "mac") { | ||
63 | return "MAC" | ||
64 | } | ||
65 | if strings.EqualFold(t.TokenType, "basic") { | ||
66 | return "Basic" | ||
67 | } | ||
68 | if t.TokenType != "" { | ||
69 | return t.TokenType | ||
70 | } | ||
71 | return "Bearer" | ||
72 | } | ||
73 | |||
74 | // SetAuthHeader sets the Authorization header to r using the access | ||
75 | // token in t. | ||
76 | // | ||
77 | // This method is unnecessary when using Transport or an HTTP Client | ||
78 | // returned by this package. | ||
79 | func (t *Token) SetAuthHeader(r *http.Request) { | ||
80 | r.Header.Set("Authorization", t.Type()+" "+t.AccessToken) | ||
81 | } | ||
82 | |||
83 | // WithExtra returns a new Token that's a clone of t, but using the | ||
84 | // provided raw extra map. This is only intended for use by packages | ||
85 | // implementing derivative OAuth2 flows. | ||
86 | func (t *Token) WithExtra(extra interface{}) *Token { | ||
87 | t2 := new(Token) | ||
88 | *t2 = *t | ||
89 | t2.raw = extra | ||
90 | return t2 | ||
91 | } | ||
92 | |||
93 | // Extra returns an extra field. | ||
94 | // Extra fields are key-value pairs returned by the server as a | ||
95 | // part of the token retrieval response. | ||
96 | func (t *Token) Extra(key string) interface{} { | ||
97 | if raw, ok := t.raw.(map[string]interface{}); ok { | ||
98 | return raw[key] | ||
99 | } | ||
100 | |||
101 | vals, ok := t.raw.(url.Values) | ||
102 | if !ok { | ||
103 | return nil | ||
104 | } | ||
105 | |||
106 | v := vals.Get(key) | ||
107 | switch s := strings.TrimSpace(v); strings.Count(s, ".") { | ||
108 | case 0: // Contains no "."; try to parse as int | ||
109 | if i, err := strconv.ParseInt(s, 10, 64); err == nil { | ||
110 | return i | ||
111 | } | ||
112 | case 1: // Contains a single "."; try to parse as float | ||
113 | if f, err := strconv.ParseFloat(s, 64); err == nil { | ||
114 | return f | ||
115 | } | ||
116 | } | ||
117 | |||
118 | return v | ||
119 | } | ||
120 | |||
121 | // timeNow is time.Now but pulled out as a variable for tests. | ||
122 | var timeNow = time.Now | ||
123 | |||
124 | // expired reports whether the token is expired. | ||
125 | // t must be non-nil. | ||
126 | func (t *Token) expired() bool { | ||
127 | if t.Expiry.IsZero() { | ||
128 | return false | ||
129 | } | ||
130 | return t.Expiry.Round(0).Add(-expiryDelta).Before(timeNow()) | ||
131 | } | ||
132 | |||
133 | // Valid reports whether t is non-nil, has an AccessToken, and is not expired. | ||
134 | func (t *Token) Valid() bool { | ||
135 | return t != nil && t.AccessToken != "" && !t.expired() | ||
136 | } | ||
137 | |||
138 | // tokenFromInternal maps an *internal.Token struct into | ||
139 | // a *Token struct. | ||
140 | func tokenFromInternal(t *internal.Token) *Token { | ||
141 | if t == nil { | ||
142 | return nil | ||
143 | } | ||
144 | return &Token{ | ||
145 | AccessToken: t.AccessToken, | ||
146 | TokenType: t.TokenType, | ||
147 | RefreshToken: t.RefreshToken, | ||
148 | Expiry: t.Expiry, | ||
149 | raw: t.Raw, | ||
150 | } | ||
151 | } | ||
152 | |||
153 | // retrieveToken takes a *Config and uses that to retrieve an *internal.Token. | ||
154 | // This token is then mapped from *internal.Token into an *oauth2.Token which is returned along | ||
155 | // with an error.. | ||
156 | func retrieveToken(ctx context.Context, c *Config, v url.Values) (*Token, error) { | ||
157 | tk, err := internal.RetrieveToken(ctx, c.ClientID, c.ClientSecret, c.Endpoint.TokenURL, v, internal.AuthStyle(c.Endpoint.AuthStyle)) | ||
158 | if err != nil { | ||
159 | if rErr, ok := err.(*internal.RetrieveError); ok { | ||
160 | return nil, (*RetrieveError)(rErr) | ||
161 | } | ||
162 | return nil, err | ||
163 | } | ||
164 | return tokenFromInternal(tk), nil | ||
165 | } | ||
166 | |||
167 | // RetrieveError is the error returned when the token endpoint returns a | ||
168 | // non-2XX HTTP status code. | ||
169 | type RetrieveError struct { | ||
170 | Response *http.Response | ||
171 | // Body is the body that was consumed by reading Response.Body. | ||
172 | // It may be truncated. | ||
173 | Body []byte | ||
174 | } | ||
175 | |||
176 | func (r *RetrieveError) Error() string { | ||
177 | return fmt.Sprintf("oauth2: cannot fetch token: %v\nResponse: %s", r.Response.Status, r.Body) | ||
178 | } | ||