func main() {
//serviceAccountJSONFile := "YOUR_SERVICE_ACCOUNT_JSON_FILE"
//dat, err := ioutil.ReadFile(serviceAccountJSONFile)
//if err != nil {
// log.Fatalf("Unable to read service account file %v", err)
//}
//conf, err := google.JWTConfigFromJSON(dat, oauthsvc.UserinfoEmailScope)
//if err != nil {
// log.Fatalf("Unable to acquire generate config: %v", err)
//}
//src := conf.TokenSource(oauth2.NoContext)
//client := conf.Client(oauth2.NoContext)
os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", serviceAccountJSONFile)
src, err := google.DefaultTokenSource(oauth2.NoContext, oauthsvc.UserinfoEmailScope)
if err != nil {
log.Fatalf("Unable to acquire token source: %v", err)
}
client := oauth2.NewClient(context.Background(), src)
service, err := oauthsvc.New(client)
if err != nil {
log.Fatalf("Unable to create api service: %v", err)
}
ui, err := service.Userinfo.Get().Do()
if err != nil {
log.Fatalf("Unable to get userinfo: ", err)
}
log.Printf("UserInfo: %v", ui.Email)
}
func getBucket(ctx context.Context) (b gcs.Bucket, err error) {
if *fBucket == "" {
err = errors.New("You must set --bucket.")
return
}
// Set up the token source.
const scope = gcs.Scope_ReadOnly
tokenSrc, err := google.DefaultTokenSource(context.Background(), scope)
if err != nil {
err = fmt.Errorf("DefaultTokenSource: %v", err)
return
}
// Use that to create a GCS connection.
cfg := &gcs.ConnConfig{
TokenSource: tokenSrc,
}
conn, err := gcs.NewConn(cfg)
if err != nil {
err = fmt.Errorf("NewConn: %v", err)
return
}
// Open the bucket.
b, err = conn.OpenBucket(ctx, *fBucket)
if err != nil {
err = fmt.Errorf("OpenBucket: %v", err)
return
}
return
}
// NewHTTPClient returns an HTTP client for use communicating with a Google cloud
// service, configured with the given ClientOptions. It also returns the endpoint
// for the service as specified in the options.
func NewHTTPClient(ctx context.Context, opts ...option.ClientOption) (*http.Client, string, error) {
var o internal.DialSettings
for _, opt := range opts {
opt.Apply(&o)
}
if o.GRPCConn != nil {
return nil, "", errors.New("unsupported gRPC connection specified")
}
// TODO(djd): Set UserAgent on all outgoing requests.
if o.HTTPClient != nil {
return o.HTTPClient, o.Endpoint, nil
}
if o.ServiceAccountJSONFilename != "" {
ts, err := serviceAcctTokenSource(ctx, o.ServiceAccountJSONFilename, o.Scopes...)
if err != nil {
return nil, "", err
}
o.TokenSource = ts
}
if o.TokenSource == nil {
var err error
o.TokenSource, err = google.DefaultTokenSource(ctx, o.Scopes...)
if err != nil {
return nil, "", fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
return oauth2.NewClient(ctx, o.TokenSource), o.Endpoint, nil
}
// NewApplicationDefault returns "Application Default Credentials". For more
// detail, see https://developers.google.com/accounts/docs/application-default-credentials.
func NewApplicationDefault(ctx context.Context, scope ...string) (credentials.PerRPCCredentials, error) {
t, err := google.DefaultTokenSource(ctx, scope...)
if err != nil {
return nil, err
}
return TokenSource{t}, nil
}
func newGCPAuthProvider() (restclient.AuthProvider, error) {
ts, err := google.DefaultTokenSource(context.TODO(), "https://www.googleapis.com/auth/cloud-platform")
if err != nil {
return nil, err
}
return &gcpAuthProvider{ts}, nil
}
// DialGRPC returns a GRPC connection for use communicating with a Google cloud
// service, configured with the given ClientOptions.
func DialGRPC(ctx context.Context, opts ...option.ClientOption) (*grpc.ClientConn, error) {
var o internal.DialSettings
for _, opt := range opts {
opt.Apply(&o)
}
if o.HTTPClient != nil {
return nil, errors.New("unsupported HTTP client specified")
}
if o.GRPCConn != nil {
return o.GRPCConn, nil
}
if o.TokenSource == nil {
var err error
o.TokenSource, err = google.DefaultTokenSource(ctx, o.Scopes...)
if err != nil {
return nil, fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
grpcOpts := []grpc.DialOption{
grpc.WithPerRPCCredentials(oauth.TokenSource{o.TokenSource}),
grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
}
if appengineDialerHook != nil {
// Use the Socket API on App Engine.
grpcOpts = append(grpcOpts, appengineDialerHook(ctx))
}
grpcOpts = append(grpcOpts, o.GRPCDialOpts...)
if o.UserAgent != "" {
grpcOpts = append(grpcOpts, grpc.WithUserAgent(o.UserAgent))
}
return grpc.Dial(o.Endpoint, grpcOpts...)
}
func mainhandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/plain")
ctx := appengine.NewContext(r)
//src := google.AppEngineTokenSource(ctx, oauthsvc.UserinfoEmailScope)
src, err := google.DefaultTokenSource(ctx, oauthsvc.UserinfoEmailScope)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
client := &http.Client{
Transport: &oauth2.Transport{
Source: src,
Base: &urlfetch.Transport{Context: ctx},
},
}
client = oauth2.NewClient(ctx, src)
service, err := oauthsvc.New(client)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
ui, err := service.Userinfo.Get().Do()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
log.Infof(ctx, "UserInfo: %v", ui.Email)
fmt.Fprintln(w, "UserInfo: ", ui.Email)
}
func getBucket() (b gcs.Bucket, err error) {
if *fBucket == "" {
err = errors.New("You must set --bucket.")
return
}
// Create the HTTP client.
const scope = gcs.Scope_FullControl
tokenSrc, err := google.DefaultTokenSource(context.Background(), scope)
if err != nil {
err = fmt.Errorf("DefaultTokenSource: %v", err)
return
}
// Set up a GCS connection.
cfg := &gcs.ConnConfig{
TokenSource: tokenSrc,
MaxBackoffSleep: 60 * time.Minute,
}
conn, err := gcs.NewConn(cfg)
if err != nil {
err = fmt.Errorf("gcs.NewConn: %v", err)
return
}
// Open the bucket.
b, err = conn.OpenBucket(context.Background(), *fBucket)
if err != nil {
err = fmt.Errorf("OpenBucket: %v", err)
return
}
return
}
func init() {
bucket := os.Getenv("REGISTRY_STORAGE_GCS_BUCKET")
credentials := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS")
// Skip GCS storage driver tests if environment variable parameters are not provided
skipGCS = func() string {
if bucket == "" || credentials == "" {
return "The following environment variables must be set to enable these tests: REGISTRY_STORAGE_GCS_BUCKET, GOOGLE_APPLICATION_CREDENTIALS"
}
return ""
}
if skipGCS() != "" {
return
}
root, err := ioutil.TempDir("", "driver-")
if err != nil {
panic(err)
}
defer os.Remove(root)
var ts oauth2.TokenSource
var email string
var privateKey []byte
ts, err = google.DefaultTokenSource(ctx.Background(), storage.ScopeFullControl)
if err != nil {
// Assume that the file contents are within the environment variable since it exists
// but does not contain a valid file path
jwtConfig, err := google.JWTConfigFromJSON([]byte(credentials), storage.ScopeFullControl)
if err != nil {
panic(fmt.Sprintf("Error reading JWT config : %s", err))
}
email = jwtConfig.Email
privateKey = []byte(jwtConfig.PrivateKey)
if len(privateKey) == 0 {
panic("Error reading JWT config : missing private_key property")
}
if email == "" {
panic("Error reading JWT config : missing client_email property")
}
ts = jwtConfig.TokenSource(ctx.Background())
}
gcsDriverConstructor = func(rootDirectory string) (storagedriver.StorageDriver, error) {
parameters := driverParameters{
bucket: bucket,
rootDirectory: root,
email: email,
privateKey: privateKey,
client: oauth2.NewClient(ctx.Background(), ts),
}
return New(parameters)
}
testsuites.RegisterSuite(func() (storagedriver.StorageDriver, error) {
return gcsDriverConstructor(root)
}, skipGCS)
}
// DialGRPC returns a GRPC connection for use communicating with a Google cloud
// service, configured with the given ClientOptions.
func DialGRPC(ctx context.Context, opt ...cloud.ClientOption) (*grpc.ClientConn, error) {
var o opts.DialOpt
for _, opt := range opt {
opt.Resolve(&o)
}
if o.HTTPClient != nil {
return nil, errors.New("unsupported HTTP base transport specified")
}
if o.GRPCClient != nil {
return o.GRPCClient, nil
}
if o.TokenSource == nil {
var err error
o.TokenSource, err = google.DefaultTokenSource(ctx, o.Scopes...)
if err != nil {
return nil, fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
grpcOpts := []grpc.DialOption{
grpc.WithPerRPCCredentials(oauth.TokenSource{o.TokenSource}),
grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
}
grpcOpts = append(grpcOpts, o.GRPCDialOpts...)
if o.UserAgent != "" {
grpcOpts = append(grpcOpts, grpc.WithUserAgent(o.UserAgent))
}
return grpc.Dial(o.Endpoint, grpcOpts...)
}
func getAppDefaultClientArgs() (*context.Context, *cloud.ClientOption, error) {
ctx := oauth2.NoContext
tokenSrc, err := google.DefaultTokenSource(ctx, ScopeCloudPlatform)
if err != nil {
return nil, nil, err
}
clientOption := cloud.WithTokenSource(tokenSrc)
return &ctx, &clientOption, nil
}
func init() {
ctx = context.Background()
var err error
defaultTokenSource, err = google.DefaultTokenSource(ctx,
storage.ScopeFullControl,
)
if err != nil || defaultTokenSource == nil {
public.LogE.Fatalf("Error getting storage token source: %s\n", err.Error())
}
}
func initGCE() error {
initGCECalled = true
// Use the staging project if not on GCE. This assumes the DefaultTokenSource
// credential used below has access to that project.
if !metadata.OnGCE() {
projectID = stagingProjectID
}
var err error
projectID, err = metadata.ProjectID()
if err != nil {
return fmt.Errorf("failed to get current GCE ProjectID: %v", err)
}
inStaging = projectID == stagingProjectID
if inStaging {
log.Printf("Running in staging cluster (%q)", projectID)
}
tokenSource, _ = google.DefaultTokenSource(oauth2.NoContext)
httpClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
serviceCtx = cloud.NewContext(projectID, httpClient)
projectZone, err = metadata.Get("instance/zone")
if err != nil || projectZone == "" {
return fmt.Errorf("failed to get current GCE zone: %v", err)
}
// Convert the zone from "projects/1234/zones/us-central1-a" to "us-central1-a".
projectZone = path.Base(projectZone)
if !hasComputeScope() {
return errors.New("The coordinator is not running with access to read and write Compute resources. VM support disabled.")
}
projectRegion = projectZone[:strings.LastIndex(projectZone, "-")] // "us-central1"
externalIP, err = metadata.ExternalIP()
if err != nil {
return fmt.Errorf("ExternalIP: %v", err)
}
computeService, _ = compute.New(httpClient)
errTryDeps = checkTryBuildDeps()
if errTryDeps != nil {
log.Printf("TryBot builders disabled due to error: %v", errTryDeps)
} else {
log.Printf("TryBot builders enabled.")
}
go gcePool.pollQuotaLoop()
return nil
}
func getToken() string {
os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", "grpc-go16-dev-608d72c9bce0.json")
const scope = "https://www.googleapis.com/auth/bigtable.data"
ts, err := google.DefaultTokenSource(context.Background(), scope)
if err != nil {
log.Fatal("DefaultTokenSource:", err)
}
tk, err := ts.Token()
if err != nil {
log.Fatal("Token:", err)
}
return tk.AccessToken
}
func NewContext() (*Context, error) {
ctx := &Context{
apiRateGate: time.NewTicker(time.Second / 10).C,
}
background := context.Background()
tokenSource, err := google.DefaultTokenSource(background, compute.CloudPlatformScope)
if err != nil {
return nil, fmt.Errorf("failed to get a token source: %v", err)
}
httpClient := oauth2.NewClient(background, tokenSource)
ctx.computeService, _ = compute.New(httpClient)
// Obtain project name, zone and current instance IP address.
ctx.ProjectID, err = ctx.getMeta("project/project-id")
if err != nil {
return nil, fmt.Errorf("failed to query gce project-id: %v", err)
}
ctx.ZoneID, err = ctx.getMeta("instance/zone")
if err != nil {
return nil, fmt.Errorf("failed to query gce zone: %v", err)
}
if i := strings.LastIndexByte(ctx.ZoneID, '/'); i != -1 {
ctx.ZoneID = ctx.ZoneID[i+1:] // the query returns some nonsense prefix
}
instID, err := ctx.getMeta("instance/id")
if err != nil {
return nil, fmt.Errorf("failed to query gce instance id: %v", err)
}
instances, err := ctx.computeService.Instances.List(ctx.ProjectID, ctx.ZoneID).Do()
if err != nil {
return nil, fmt.Errorf("error getting instance list: %v", err)
}
// Finds this instance internal IP.
for _, inst := range instances.Items {
if fmt.Sprint(inst.Id) != instID {
continue
}
ctx.Instance = inst.Name
for _, iface := range inst.NetworkInterfaces {
if strings.HasPrefix(iface.NetworkIP, "10.") {
ctx.InternalIP = iface.NetworkIP
break
}
}
break
}
if ctx.Instance == "" || ctx.InternalIP == "" {
return nil, fmt.Errorf("failed to get current instance name and internal IP")
}
return ctx, nil
}
func init() {
makeDeps := func(ctx context.Context) (deps gcstesting.BucketTestDeps) {
var err error
// Set up the token source.
const scope = gcs.Scope_FullControl
tokenSrc, err := google.DefaultTokenSource(context.Background(), scope)
AssertEq(nil, err)
// Use that to create a GCS connection, enabling retry if requested.
cfg := &gcs.ConnConfig{
TokenSource: tokenSrc,
}
if *fUseRetry {
cfg.MaxBackoffSleep = 5 * time.Minute
deps.BuffersEntireContentsForCreate = true
}
if *fDebugGCS {
cfg.GCSDebugLogger = log.New(os.Stderr, "gcs: ", 0)
}
if *fDebugHTTP {
cfg.HTTPDebugLogger = log.New(os.Stderr, "http: ", 0)
}
conn, err := gcs.NewConn(cfg)
AssertEq(nil, err)
// Open the bucket.
deps.Bucket, err = conn.OpenBucket(ctx, *fBucket)
AssertEq(nil, err)
// Clear the bucket.
err = gcsutil.DeleteAllObjects(ctx, deps.Bucket)
if err != nil {
panic("DeleteAllObjects: " + err.Error())
}
// Set up other information.
deps.Clock = timeutil.RealClock()
deps.SupportsCancellation = true
return
}
gcstesting.RegisterBucketTests(makeDeps)
}
func newCachedTokenSource(accessToken, expiry string, persister restclient.AuthProviderConfigPersister) (*cachedTokenSource, error) {
var expiryTime time.Time
if parsedTime, err := time.Parse(time.RFC3339Nano, expiry); err == nil {
expiryTime = parsedTime
}
ts, err := google.DefaultTokenSource(context.Background(), "https://www.googleapis.com/auth/cloud-platform")
if err != nil {
return nil, err
}
return &cachedTokenSource{
source: ts,
accessToken: accessToken,
expiry: expiryTime,
persister: persister,
}, nil
}
// GCEClientInit uses Google's host FS searching functionality to find auth
// tokens if they exist. eg: GCE VMs, Authenticated Developers
func GCEClientInit(ctx *context.Context, project string) *pubsub.Client {
var client *pubsub.Client
clientOnce := new(sync.Once)
clientOnce.Do(func() {
source, err := google.DefaultTokenSource(*ctx, pubsub.ScopePubSub)
if err != nil {
log.Errorf("error creating token source: %v", err)
os.Exit(1)
}
client, err = pubsub.NewClient(*ctx, project, cloud.WithTokenSource(source))
if err != nil {
log.Errorf("error creating pubsub.Client: %v", err)
os.Exit(1)
}
})
return client
}
func getConn() (c gcs.Conn, err error) {
// Create the oauth2 token source.
const scope = gcs.Scope_FullControl
tokenSrc, err := google.DefaultTokenSource(context.Background(), scope)
if err != nil {
return nil, err
}
// Create the connection.
const userAgent = "gcsfuse/0.0"
cfg := &gcs.ConnConfig{
TokenSource: tokenSrc,
UserAgent: userAgent,
}
return gcs.NewConn(cfg)
}
func main() {
//src := google.ComputeTokenSource("")
src, err := google.DefaultTokenSource(oauth2.NoContext, oauthsvc.UserinfoEmailScope)
if err != nil {
log.Fatalf("Unable to acquire token source: %v", err)
}
client := oauth2.NewClient(context.Background(), src)
service, err := oauthsvc.New(client)
if err != nil {
log.Fatalf("Unable to create api service: %v", err)
}
ui, err := service.Userinfo.Get().Do()
if err != nil {
log.Fatalf("Unable to get userinfo: ", err)
}
log.Printf("UserInfo: %v", ui.Email)
}
func newGCPAuthProvider(_ string, gcpConfig map[string]string, persister restclient.AuthProviderConfigPersister) (restclient.AuthProvider, error) {
cmd, useCmd := gcpConfig["cmd-path"]
var ts oauth2.TokenSource
var err error
if useCmd {
ts, err = newCmdTokenSource(cmd, gcpConfig["token-key"], gcpConfig["expiry-key"], gcpConfig["time-fmt"])
} else {
ts, err = google.DefaultTokenSource(context.Background(), "https://www.googleapis.com/auth/cloud-platform")
}
if err != nil {
return nil, err
}
cts, err := newCachedTokenSource(gcpConfig["access-token"], gcpConfig["expiry"], persister, ts, gcpConfig)
if err != nil {
return nil, err
}
return &gcpAuthProvider{cts, persister}, nil
}
func (t *ConnTest) SetUp(ti *TestInfo) {
var err error
t.ctx = ti.Ctx
// Set up a token source.
const scope = gcs.Scope_FullControl
tokenSrc, err := google.DefaultTokenSource(context.Background(), scope)
AssertEq(nil, err)
// Use that to create a GCS connection, enabling retry if requested.
cfg := &gcs.ConnConfig{
TokenSource: tokenSrc,
}
t.conn, err = gcs.NewConn(cfg)
AssertEq(nil, err)
}
func connectBigQueryDB() (*bqDataset, error) {
projectId := "cometiphrd"
datasetId := "appstore" //"october"
tableId := "data" //"data_test"
// Use oauth2.NoContext if there isn't a good context to pass in.
ctx := context.Background()
ts, err := google.DefaultTokenSource(ctx, bigquery.BigqueryScope,
//storage.DevstorageReadOnlyScope,
"https://www.googleapis.com/auth/userinfo.profile")
if err != nil {
//...
}
client := oauth2.NewClient(ctx, ts)
return newBQDataset(client, projectId, datasetId, tableId)
}
func main() {
// Use oauth2.NoContext if there isn't a good context to pass in.
ctx := context.TODO()
ts, err := google.DefaultTokenSource(ctx)
if err != nil {
fmt.Print(err)
return
}
token, tErr := ts.Token()
if tErr != nil {
fmt.Print(tErr)
return
}
fmt.Println("Successfully retrieved token!")
fmt.Println(token)
}
func tokenSource() oauth2.TokenSource {
var tokensource oauth2.TokenSource
tokenSource, err := google.DefaultTokenSource(oauth2.NoContext)
if err == nil {
return tokenSource
}
oauthConfig := &oauth2.Config{
// The client-id and secret should be for an "Installed Application" when using
// the CLI. Later we'll use a web application with a callback.
ClientID: readFile(stagingPrefix() + "client-id.dat"),
ClientSecret: readFile(stagingPrefix() + "client-secret.dat"),
Endpoint: google.Endpoint,
Scopes: []string{
compute.DevstorageFullControlScope,
compute.ComputeScope,
compute.CloudPlatformScope,
"https://www.googleapis.com/auth/sqlservice",
"https://www.googleapis.com/auth/sqlservice.admin",
},
RedirectURL: "urn:ietf:wg:oauth:2.0:oob",
}
tokenFileName := stagingPrefix() + "token.dat"
tokenFile := tokenCacheFile(tokenFileName)
tokenSource = oauth2.ReuseTokenSource(nil, tokenFile)
token, err := tokenSource.Token()
if err != nil {
log.Printf("Error getting token from %s: %v", tokenFileName, err)
log.Printf("Get auth code from %v", oauthConfig.AuthCodeURL("my-state"))
fmt.Print("\nEnter auth code: ")
sc := bufio.NewScanner(os.Stdin)
sc.Scan()
authCode := strings.TrimSpace(sc.Text())
token, err = oauthConfig.Exchange(oauth2.NoContext, authCode)
if err != nil {
log.Fatalf("Error exchanging auth code for a token: %v", err)
}
if err := tokenFile.WriteToken(token); err != nil {
log.Fatalf("Error writing to %s: %v", tokenFileName, err)
}
tokenSource = oauth2.ReuseTokenSource(token, nil)
}
return tokensource
}
// FromParameters constructs a new Driver with a given parameters map
// Required parameters:
// - bucket
func FromParameters(parameters map[string]interface{}) (storagedriver.StorageDriver, error) {
bucket, ok := parameters["bucket"]
if !ok || fmt.Sprint(bucket) == "" {
return nil, fmt.Errorf("No bucket parameter provided")
}
rootDirectory, ok := parameters["rootdirectory"]
if !ok {
rootDirectory = ""
}
var ts oauth2.TokenSource
jwtConf := new(jwt.Config)
if keyfile, ok := parameters["keyfile"]; ok {
jsonKey, err := ioutil.ReadFile(fmt.Sprint(keyfile))
if err != nil {
return nil, err
}
jwtConf, err = google.JWTConfigFromJSON(jsonKey, storage.ScopeFullControl)
if err != nil {
return nil, err
}
ts = jwtConf.TokenSource(context.Background())
} else {
var err error
ts, err = google.DefaultTokenSource(context.Background(), storage.ScopeFullControl)
if err != nil {
return nil, err
}
}
params := driverParameters{
bucket: fmt.Sprint(bucket),
rootDirectory: fmt.Sprint(rootDirectory),
email: jwtConf.Email,
privateKey: jwtConf.PrivateKey,
client: oauth2.NewClient(context.Background(), ts),
}
return New(params)
}
func DialGRPC(ctx context.Context, opts ...ClientOption) (*grpc.ClientConn, error) {
settings := &ClientSettings{}
clientOptions(opts).Resolve(settings)
if settings.Connection != nil {
return settings.Connection, nil
}
var dialOpts = settings.DialOptions
if len(dialOpts) == 0 {
tokenSource, err := google.DefaultTokenSource(ctx, settings.Scopes...)
if err != nil {
return nil, fmt.Errorf("google.DefaultTokenSource: %v", err)
}
dialOpts = []grpc.DialOption{
grpc.WithPerRPCCredentials(oauth.TokenSource{TokenSource: tokenSource}),
grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
}
}
return grpc.Dial(settings.Endpoint, dialOpts...)
}
// New constructs a new driver
func New(params driverParameters) (storagedriver.StorageDriver, error) {
var ts oauth2.TokenSource
var err error
rootDirectory := strings.Trim(params.rootDirectory, "/")
if rootDirectory != "" {
rootDirectory += "/"
}
d := &driver{
bucket: params.bucket,
rootDirectory: rootDirectory,
}
if params.keyfile == "" {
ts, err = google.DefaultTokenSource(context.Background(), storage.ScopeFullControl)
if err != nil {
return nil, err
}
} else {
jsonKey, err := ioutil.ReadFile(params.keyfile)
if err != nil {
return nil, err
}
conf, err := google.JWTConfigFromJSON(
jsonKey,
storage.ScopeFullControl,
)
if err != nil {
return nil, err
}
ts = conf.TokenSource(context.Background())
d.email = conf.Email
d.privateKey = conf.PrivateKey
}
client := oauth2.NewClient(context.Background(), ts)
d.client = client
if err != nil {
return nil, err
}
return &base.Base{
StorageDriver: d,
}, nil
}
// DialHTTP returns an HTTP client for use communicating with a Google cloud
// service, configured with the given ClientOptions. Most developers should
// call the relevant NewClient method for the target service rather than
// invoking DialHTTP directly.
func DialHTTP(ctx context.Context, opt ...ClientOption) (*http.Client, error) {
var o dialOpt
for _, opt := range opt {
opt.resolve(&o)
}
if o.grpcClient != nil {
return nil, errors.New("unsupported GRPC base transport specified")
}
// TODO(djd): Wrap all http.Client's with appropriate internal version to add
// UserAgent header and prepend correct endpoint.
if o.httpClient != nil {
return o.httpClient, nil
}
if o.tokenSource == nil {
var err error
o.tokenSource, err = google.DefaultTokenSource(ctx, o.scopes...)
if err != nil {
return nil, fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
return oauth2.NewClient(ctx, o.tokenSource), nil
}
// NewHTTPClient returns an HTTP client for use communicating with a Google cloud
// service, configured with the given ClientOptions. It also returns the endpoint
// for the service as specified in the options.
func NewHTTPClient(ctx context.Context, opt ...cloud.ClientOption) (*http.Client, string, error) {
var o opts.DialOpt
for _, opt := range opt {
opt.Resolve(&o)
}
if o.GRPCClient != nil {
return nil, "", errors.New("unsupported GRPC base transport specified")
}
// TODO(djd): Wrap all http.Clients with appropriate internal version to add
// UserAgent header and prepend correct endpoint.
if o.HTTPClient != nil {
return o.HTTPClient, o.Endpoint, nil
}
if o.TokenSource == nil {
var err error
o.TokenSource, err = google.DefaultTokenSource(ctx, o.Scopes...)
if err != nil {
return nil, "", fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
return oauth2.NewClient(ctx, o.TokenSource), o.Endpoint, nil
}