mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-06 17:16:44 +00:00
![Paddy](/assets/img/avatar_default.png)
Switch to using Go modules. This migrates our vendor.json to use Go 1.11's modules system, and replaces the vendor folder with the output of go mod vendor. The vendored code should remain basically the same; I believe some tree shaking of packages and support scripts/licenses/READMEs/etc. happened. This also fixes Travis and our Makefile to no longer use govendor.
148 lines
4.4 KiB
Go
148 lines
4.4 KiB
Go
// Copyright 2015 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// Package http supports network connections to HTTP servers.
|
|
// This package is not intended for use by end developers. Use the
|
|
// google.golang.org/api/option package to configure API clients.
|
|
package http
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
|
|
"go.opencensus.io/plugin/ochttp"
|
|
"golang.org/x/oauth2"
|
|
"google.golang.org/api/googleapi/transport"
|
|
"google.golang.org/api/internal"
|
|
"google.golang.org/api/option"
|
|
"google.golang.org/api/transport/http/internal/propagation"
|
|
)
|
|
|
|
// NewClient 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 NewClient(ctx context.Context, opts ...option.ClientOption) (*http.Client, string, error) {
|
|
settings, err := newSettings(opts)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
// TODO(cbro): consider injecting the User-Agent even if an explicit HTTP client is provided?
|
|
if settings.HTTPClient != nil {
|
|
return settings.HTTPClient, settings.Endpoint, nil
|
|
}
|
|
trans, err := newTransport(ctx, defaultBaseTransport(ctx), settings)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
return &http.Client{Transport: trans}, settings.Endpoint, nil
|
|
}
|
|
|
|
// NewTransport creates an http.RoundTripper for use communicating with a Google
|
|
// cloud service, configured with the given ClientOptions. Its RoundTrip method delegates to base.
|
|
func NewTransport(ctx context.Context, base http.RoundTripper, opts ...option.ClientOption) (http.RoundTripper, error) {
|
|
settings, err := newSettings(opts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if settings.HTTPClient != nil {
|
|
return nil, errors.New("transport/http: WithHTTPClient passed to NewTransport")
|
|
}
|
|
return newTransport(ctx, base, settings)
|
|
}
|
|
|
|
func newTransport(ctx context.Context, base http.RoundTripper, settings *internal.DialSettings) (http.RoundTripper, error) {
|
|
trans := base
|
|
trans = userAgentTransport{
|
|
base: trans,
|
|
userAgent: settings.UserAgent,
|
|
}
|
|
trans = addOCTransport(trans)
|
|
switch {
|
|
case settings.NoAuth:
|
|
// Do nothing.
|
|
case settings.APIKey != "":
|
|
trans = &transport.APIKey{
|
|
Transport: trans,
|
|
Key: settings.APIKey,
|
|
}
|
|
default:
|
|
creds, err := internal.Creds(ctx, settings)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
trans = &oauth2.Transport{
|
|
Base: trans,
|
|
Source: creds.TokenSource,
|
|
}
|
|
}
|
|
return trans, nil
|
|
}
|
|
|
|
func newSettings(opts []option.ClientOption) (*internal.DialSettings, error) {
|
|
var o internal.DialSettings
|
|
for _, opt := range opts {
|
|
opt.Apply(&o)
|
|
}
|
|
if err := o.Validate(); err != nil {
|
|
return nil, err
|
|
}
|
|
if o.GRPCConn != nil {
|
|
return nil, errors.New("unsupported gRPC connection specified")
|
|
}
|
|
return &o, nil
|
|
}
|
|
|
|
type userAgentTransport struct {
|
|
userAgent string
|
|
base http.RoundTripper
|
|
}
|
|
|
|
func (t userAgentTransport) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
rt := t.base
|
|
if rt == nil {
|
|
return nil, errors.New("transport: no Transport specified")
|
|
}
|
|
if t.userAgent == "" {
|
|
return rt.RoundTrip(req)
|
|
}
|
|
newReq := *req
|
|
newReq.Header = make(http.Header)
|
|
for k, vv := range req.Header {
|
|
newReq.Header[k] = vv
|
|
}
|
|
// TODO(cbro): append to existing User-Agent header?
|
|
newReq.Header["User-Agent"] = []string{t.userAgent}
|
|
return rt.RoundTrip(&newReq)
|
|
}
|
|
|
|
// Set at init time by dial_appengine.go. If nil, we're not on App Engine.
|
|
var appengineUrlfetchHook func(context.Context) http.RoundTripper
|
|
|
|
// defaultBaseTransport returns the base HTTP transport.
|
|
// On App Engine, this is urlfetch.Transport, otherwise it's http.DefaultTransport.
|
|
func defaultBaseTransport(ctx context.Context) http.RoundTripper {
|
|
if appengineUrlfetchHook != nil {
|
|
return appengineUrlfetchHook(ctx)
|
|
}
|
|
return http.DefaultTransport
|
|
}
|
|
|
|
func addOCTransport(trans http.RoundTripper) http.RoundTripper {
|
|
return &ochttp.Transport{
|
|
Base: trans,
|
|
Propagation: &propagation.HTTPFormat{},
|
|
}
|
|
}
|