mirror of https://github.com/docker/docs.git
101 lines
3.2 KiB
Go
101 lines
3.2 KiB
Go
// Copyright 2011 The goauth2 Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This program makes a call to the specified API, authenticated with OAuth2.
|
|
// a list of example APIs can be found at https://code.google.com/oauthplayground/
|
|
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
|
|
"code.google.com/p/goauth2/oauth"
|
|
)
|
|
|
|
var (
|
|
clientId = flag.String("id", "", "Client ID")
|
|
clientSecret = flag.String("secret", "", "Client Secret")
|
|
scope = flag.String("scope", "https://www.googleapis.com/auth/userinfo.profile", "OAuth scope")
|
|
redirectURL = flag.String("redirect_url", "oob", "Redirect URL")
|
|
authURL = flag.String("auth_url", "https://accounts.google.com/o/oauth2/auth", "Authentication URL")
|
|
tokenURL = flag.String("token_url", "https://accounts.google.com/o/oauth2/token", "Token URL")
|
|
requestURL = flag.String("request_url", "https://www.googleapis.com/oauth2/v1/userinfo", "API request")
|
|
code = flag.String("code", "", "Authorization Code")
|
|
cachefile = flag.String("cache", "cache.json", "Token cache file")
|
|
)
|
|
|
|
const usageMsg = `
|
|
To obtain a request token you must specify both -id and -secret.
|
|
|
|
To obtain Client ID and Secret, see the "OAuth 2 Credentials" section under
|
|
the "API Access" tab on this page: https://code.google.com/apis/console/
|
|
|
|
Once you have completed the OAuth flow, the credentials should be stored inside
|
|
the file specified by -cache and you may run without the -id and -secret flags.
|
|
`
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
|
|
// Set up a configuration.
|
|
config := &oauth.Config{
|
|
ClientId: *clientId,
|
|
ClientSecret: *clientSecret,
|
|
RedirectURL: *redirectURL,
|
|
Scope: *scope,
|
|
AuthURL: *authURL,
|
|
TokenURL: *tokenURL,
|
|
TokenCache: oauth.CacheFile(*cachefile),
|
|
}
|
|
|
|
// Set up a Transport using the config.
|
|
transport := &oauth.Transport{Config: config}
|
|
|
|
// Try to pull the token from the cache; if this fails, we need to get one.
|
|
token, err := config.TokenCache.Token()
|
|
if err != nil {
|
|
if *clientId == "" || *clientSecret == "" {
|
|
flag.Usage()
|
|
fmt.Fprint(os.Stderr, usageMsg)
|
|
os.Exit(2)
|
|
}
|
|
if *code == "" {
|
|
// Get an authorization code from the data provider.
|
|
// ("Please ask the user if I can access this resource.")
|
|
url := config.AuthCodeURL("")
|
|
fmt.Print("Visit this URL to get a code, then run again with -code=YOUR_CODE\n\n")
|
|
fmt.Println(url)
|
|
return
|
|
}
|
|
// Exchange the authorization code for an access token.
|
|
// ("Here's the code you gave the user, now give me a token!")
|
|
token, err = transport.Exchange(*code)
|
|
if err != nil {
|
|
log.Fatal("Exchange:", err)
|
|
}
|
|
// (The Exchange method will automatically cache the token.)
|
|
fmt.Printf("Token is cached in %v\n", config.TokenCache)
|
|
}
|
|
|
|
// Make the actual request using the cached token to authenticate.
|
|
// ("Here's the token, let me in!")
|
|
transport.Token = token
|
|
|
|
// Make the request.
|
|
r, err := transport.Client().Get(*requestURL)
|
|
if err != nil {
|
|
log.Fatal("Get:", err)
|
|
}
|
|
defer r.Body.Close()
|
|
|
|
// Write the response to standard output.
|
|
io.Copy(os.Stdout, r.Body)
|
|
|
|
// Send final carriage return, just to be neat.
|
|
fmt.Println()
|
|
}
|