mirror of
https://github.com/letic/terraform-provider-google.git
synced 2024-09-06 09:06: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.
502 lines
16 KiB
Go
502 lines
16 KiB
Go
// Copyright 2014 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 metadata provides access to Google Compute Engine (GCE)
|
|
// metadata and API service accounts.
|
|
//
|
|
// This package is a wrapper around the GCE metadata service,
|
|
// as documented at https://developers.google.com/compute/docs/metadata.
|
|
package metadata // import "cloud.google.com/go/compute/metadata"
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"runtime"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
// metadataIP is the documented metadata server IP address.
|
|
metadataIP = "169.254.169.254"
|
|
|
|
// metadataHostEnv is the environment variable specifying the
|
|
// GCE metadata hostname. If empty, the default value of
|
|
// metadataIP ("169.254.169.254") is used instead.
|
|
// This is variable name is not defined by any spec, as far as
|
|
// I know; it was made up for the Go package.
|
|
metadataHostEnv = "GCE_METADATA_HOST"
|
|
|
|
userAgent = "gcloud-golang/0.1"
|
|
)
|
|
|
|
type cachedValue struct {
|
|
k string
|
|
trim bool
|
|
mu sync.Mutex
|
|
v string
|
|
}
|
|
|
|
var (
|
|
projID = &cachedValue{k: "project/project-id", trim: true}
|
|
projNum = &cachedValue{k: "project/numeric-project-id", trim: true}
|
|
instID = &cachedValue{k: "instance/id", trim: true}
|
|
)
|
|
|
|
var (
|
|
defaultClient = &Client{hc: &http.Client{
|
|
Transport: &http.Transport{
|
|
Dial: (&net.Dialer{
|
|
Timeout: 2 * time.Second,
|
|
KeepAlive: 30 * time.Second,
|
|
}).Dial,
|
|
ResponseHeaderTimeout: 2 * time.Second,
|
|
},
|
|
}}
|
|
subscribeClient = &Client{hc: &http.Client{
|
|
Transport: &http.Transport{
|
|
Dial: (&net.Dialer{
|
|
Timeout: 2 * time.Second,
|
|
KeepAlive: 30 * time.Second,
|
|
}).Dial,
|
|
},
|
|
}}
|
|
)
|
|
|
|
// NotDefinedError is returned when requested metadata is not defined.
|
|
//
|
|
// The underlying string is the suffix after "/computeMetadata/v1/".
|
|
//
|
|
// This error is not returned if the value is defined to be the empty
|
|
// string.
|
|
type NotDefinedError string
|
|
|
|
func (suffix NotDefinedError) Error() string {
|
|
return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix))
|
|
}
|
|
|
|
func (c *cachedValue) get(cl *Client) (v string, err error) {
|
|
defer c.mu.Unlock()
|
|
c.mu.Lock()
|
|
if c.v != "" {
|
|
return c.v, nil
|
|
}
|
|
if c.trim {
|
|
v, err = cl.getTrimmed(c.k)
|
|
} else {
|
|
v, err = cl.Get(c.k)
|
|
}
|
|
if err == nil {
|
|
c.v = v
|
|
}
|
|
return
|
|
}
|
|
|
|
var (
|
|
onGCEOnce sync.Once
|
|
onGCE bool
|
|
)
|
|
|
|
// OnGCE reports whether this process is running on Google Compute Engine.
|
|
func OnGCE() bool {
|
|
onGCEOnce.Do(initOnGCE)
|
|
return onGCE
|
|
}
|
|
|
|
func initOnGCE() {
|
|
onGCE = testOnGCE()
|
|
}
|
|
|
|
func testOnGCE() bool {
|
|
// The user explicitly said they're on GCE, so trust them.
|
|
if os.Getenv(metadataHostEnv) != "" {
|
|
return true
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
resc := make(chan bool, 2)
|
|
|
|
// Try two strategies in parallel.
|
|
// See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/194
|
|
go func() {
|
|
req, _ := http.NewRequest("GET", "http://"+metadataIP, nil)
|
|
req.Header.Set("User-Agent", userAgent)
|
|
res, err := defaultClient.hc.Do(req.WithContext(ctx))
|
|
if err != nil {
|
|
resc <- false
|
|
return
|
|
}
|
|
defer res.Body.Close()
|
|
resc <- res.Header.Get("Metadata-Flavor") == "Google"
|
|
}()
|
|
|
|
go func() {
|
|
addrs, err := net.LookupHost("metadata.google.internal")
|
|
if err != nil || len(addrs) == 0 {
|
|
resc <- false
|
|
return
|
|
}
|
|
resc <- strsContains(addrs, metadataIP)
|
|
}()
|
|
|
|
tryHarder := systemInfoSuggestsGCE()
|
|
if tryHarder {
|
|
res := <-resc
|
|
if res {
|
|
// The first strategy succeeded, so let's use it.
|
|
return true
|
|
}
|
|
// Wait for either the DNS or metadata server probe to
|
|
// contradict the other one and say we are running on
|
|
// GCE. Give it a lot of time to do so, since the system
|
|
// info already suggests we're running on a GCE BIOS.
|
|
timer := time.NewTimer(5 * time.Second)
|
|
defer timer.Stop()
|
|
select {
|
|
case res = <-resc:
|
|
return res
|
|
case <-timer.C:
|
|
// Too slow. Who knows what this system is.
|
|
return false
|
|
}
|
|
}
|
|
|
|
// There's no hint from the system info that we're running on
|
|
// GCE, so use the first probe's result as truth, whether it's
|
|
// true or false. The goal here is to optimize for speed for
|
|
// users who are NOT running on GCE. We can't assume that
|
|
// either a DNS lookup or an HTTP request to a blackholed IP
|
|
// address is fast. Worst case this should return when the
|
|
// metaClient's Transport.ResponseHeaderTimeout or
|
|
// Transport.Dial.Timeout fires (in two seconds).
|
|
return <-resc
|
|
}
|
|
|
|
// systemInfoSuggestsGCE reports whether the local system (without
|
|
// doing network requests) suggests that we're running on GCE. If this
|
|
// returns true, testOnGCE tries a bit harder to reach its metadata
|
|
// server.
|
|
func systemInfoSuggestsGCE() bool {
|
|
if runtime.GOOS != "linux" {
|
|
// We don't have any non-Linux clues available, at least yet.
|
|
return false
|
|
}
|
|
slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name")
|
|
name := strings.TrimSpace(string(slurp))
|
|
return name == "Google" || name == "Google Compute Engine"
|
|
}
|
|
|
|
// Subscribe calls Client.Subscribe on a client designed for subscribing (one with no
|
|
// ResponseHeaderTimeout).
|
|
func Subscribe(suffix string, fn func(v string, ok bool) error) error {
|
|
return subscribeClient.Subscribe(suffix, fn)
|
|
}
|
|
|
|
// Get calls Client.Get on the default client.
|
|
func Get(suffix string) (string, error) { return defaultClient.Get(suffix) }
|
|
|
|
// ProjectID returns the current instance's project ID string.
|
|
func ProjectID() (string, error) { return defaultClient.ProjectID() }
|
|
|
|
// NumericProjectID returns the current instance's numeric project ID.
|
|
func NumericProjectID() (string, error) { return defaultClient.NumericProjectID() }
|
|
|
|
// InternalIP returns the instance's primary internal IP address.
|
|
func InternalIP() (string, error) { return defaultClient.InternalIP() }
|
|
|
|
// ExternalIP returns the instance's primary external (public) IP address.
|
|
func ExternalIP() (string, error) { return defaultClient.ExternalIP() }
|
|
|
|
// Hostname returns the instance's hostname. This will be of the form
|
|
// "<instanceID>.c.<projID>.internal".
|
|
func Hostname() (string, error) { return defaultClient.Hostname() }
|
|
|
|
// InstanceTags returns the list of user-defined instance tags,
|
|
// assigned when initially creating a GCE instance.
|
|
func InstanceTags() ([]string, error) { return defaultClient.InstanceTags() }
|
|
|
|
// InstanceID returns the current VM's numeric instance ID.
|
|
func InstanceID() (string, error) { return defaultClient.InstanceID() }
|
|
|
|
// InstanceName returns the current VM's instance ID string.
|
|
func InstanceName() (string, error) { return defaultClient.InstanceName() }
|
|
|
|
// Zone returns the current VM's zone, such as "us-central1-b".
|
|
func Zone() (string, error) { return defaultClient.Zone() }
|
|
|
|
// InstanceAttributes calls Client.InstanceAttributes on the default client.
|
|
func InstanceAttributes() ([]string, error) { return defaultClient.InstanceAttributes() }
|
|
|
|
// ProjectAttributes calls Client.ProjectAttributes on the default client.
|
|
func ProjectAttributes() ([]string, error) { return defaultClient.ProjectAttributes() }
|
|
|
|
// InstanceAttributeValue calls Client.InstanceAttributeValue on the default client.
|
|
func InstanceAttributeValue(attr string) (string, error) {
|
|
return defaultClient.InstanceAttributeValue(attr)
|
|
}
|
|
|
|
// ProjectAttributeValue calls Client.ProjectAttributeValue on the default client.
|
|
func ProjectAttributeValue(attr string) (string, error) {
|
|
return defaultClient.ProjectAttributeValue(attr)
|
|
}
|
|
|
|
// Scopes calls Client.Scopes on the default client.
|
|
func Scopes(serviceAccount string) ([]string, error) { return defaultClient.Scopes(serviceAccount) }
|
|
|
|
func strsContains(ss []string, s string) bool {
|
|
for _, v := range ss {
|
|
if v == s {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// A Client provides metadata.
|
|
type Client struct {
|
|
hc *http.Client
|
|
}
|
|
|
|
// NewClient returns a Client that can be used to fetch metadata. All HTTP requests
|
|
// will use the given http.Client instead of the default client.
|
|
func NewClient(c *http.Client) *Client {
|
|
return &Client{hc: c}
|
|
}
|
|
|
|
// getETag returns a value from the metadata service as well as the associated ETag.
|
|
// This func is otherwise equivalent to Get.
|
|
func (c *Client) getETag(suffix string) (value, etag string, err error) {
|
|
// Using a fixed IP makes it very difficult to spoof the metadata service in
|
|
// a container, which is an important use-case for local testing of cloud
|
|
// deployments. To enable spoofing of the metadata service, the environment
|
|
// variable GCE_METADATA_HOST is first inspected to decide where metadata
|
|
// requests shall go.
|
|
host := os.Getenv(metadataHostEnv)
|
|
if host == "" {
|
|
// Using 169.254.169.254 instead of "metadata" here because Go
|
|
// binaries built with the "netgo" tag and without cgo won't
|
|
// know the search suffix for "metadata" is
|
|
// ".google.internal", and this IP address is documented as
|
|
// being stable anyway.
|
|
host = metadataIP
|
|
}
|
|
url := "http://" + host + "/computeMetadata/v1/" + suffix
|
|
req, _ := http.NewRequest("GET", url, nil)
|
|
req.Header.Set("Metadata-Flavor", "Google")
|
|
req.Header.Set("User-Agent", userAgent)
|
|
res, err := c.hc.Do(req)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
defer res.Body.Close()
|
|
if res.StatusCode == http.StatusNotFound {
|
|
return "", "", NotDefinedError(suffix)
|
|
}
|
|
if res.StatusCode != 200 {
|
|
return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url)
|
|
}
|
|
all, err := ioutil.ReadAll(res.Body)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
return string(all), res.Header.Get("Etag"), nil
|
|
}
|
|
|
|
// Get returns a value from the metadata service.
|
|
// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
|
|
//
|
|
// If the GCE_METADATA_HOST environment variable is not defined, a default of
|
|
// 169.254.169.254 will be used instead.
|
|
//
|
|
// If the requested metadata is not defined, the returned error will
|
|
// be of type NotDefinedError.
|
|
func (c *Client) Get(suffix string) (string, error) {
|
|
val, _, err := c.getETag(suffix)
|
|
return val, err
|
|
}
|
|
|
|
func (c *Client) getTrimmed(suffix string) (s string, err error) {
|
|
s, err = c.Get(suffix)
|
|
s = strings.TrimSpace(s)
|
|
return
|
|
}
|
|
|
|
func (c *Client) lines(suffix string) ([]string, error) {
|
|
j, err := c.Get(suffix)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
s := strings.Split(strings.TrimSpace(j), "\n")
|
|
for i := range s {
|
|
s[i] = strings.TrimSpace(s[i])
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// ProjectID returns the current instance's project ID string.
|
|
func (c *Client) ProjectID() (string, error) { return projID.get(c) }
|
|
|
|
// NumericProjectID returns the current instance's numeric project ID.
|
|
func (c *Client) NumericProjectID() (string, error) { return projNum.get(c) }
|
|
|
|
// InstanceID returns the current VM's numeric instance ID.
|
|
func (c *Client) InstanceID() (string, error) { return instID.get(c) }
|
|
|
|
// InternalIP returns the instance's primary internal IP address.
|
|
func (c *Client) InternalIP() (string, error) {
|
|
return c.getTrimmed("instance/network-interfaces/0/ip")
|
|
}
|
|
|
|
// ExternalIP returns the instance's primary external (public) IP address.
|
|
func (c *Client) ExternalIP() (string, error) {
|
|
return c.getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip")
|
|
}
|
|
|
|
// Hostname returns the instance's hostname. This will be of the form
|
|
// "<instanceID>.c.<projID>.internal".
|
|
func (c *Client) Hostname() (string, error) {
|
|
return c.getTrimmed("instance/hostname")
|
|
}
|
|
|
|
// InstanceTags returns the list of user-defined instance tags,
|
|
// assigned when initially creating a GCE instance.
|
|
func (c *Client) InstanceTags() ([]string, error) {
|
|
var s []string
|
|
j, err := c.Get("instance/tags")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil {
|
|
return nil, err
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// InstanceName returns the current VM's instance ID string.
|
|
func (c *Client) InstanceName() (string, error) {
|
|
host, err := c.Hostname()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return strings.Split(host, ".")[0], nil
|
|
}
|
|
|
|
// Zone returns the current VM's zone, such as "us-central1-b".
|
|
func (c *Client) Zone() (string, error) {
|
|
zone, err := c.getTrimmed("instance/zone")
|
|
// zone is of the form "projects/<projNum>/zones/<zoneName>".
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return zone[strings.LastIndex(zone, "/")+1:], nil
|
|
}
|
|
|
|
// InstanceAttributes returns the list of user-defined attributes,
|
|
// assigned when initially creating a GCE VM instance. The value of an
|
|
// attribute can be obtained with InstanceAttributeValue.
|
|
func (c *Client) InstanceAttributes() ([]string, error) { return c.lines("instance/attributes/") }
|
|
|
|
// ProjectAttributes returns the list of user-defined attributes
|
|
// applying to the project as a whole, not just this VM. The value of
|
|
// an attribute can be obtained with ProjectAttributeValue.
|
|
func (c *Client) ProjectAttributes() ([]string, error) { return c.lines("project/attributes/") }
|
|
|
|
// InstanceAttributeValue returns the value of the provided VM
|
|
// instance attribute.
|
|
//
|
|
// If the requested attribute is not defined, the returned error will
|
|
// be of type NotDefinedError.
|
|
//
|
|
// InstanceAttributeValue may return ("", nil) if the attribute was
|
|
// defined to be the empty string.
|
|
func (c *Client) InstanceAttributeValue(attr string) (string, error) {
|
|
return c.Get("instance/attributes/" + attr)
|
|
}
|
|
|
|
// ProjectAttributeValue returns the value of the provided
|
|
// project attribute.
|
|
//
|
|
// If the requested attribute is not defined, the returned error will
|
|
// be of type NotDefinedError.
|
|
//
|
|
// ProjectAttributeValue may return ("", nil) if the attribute was
|
|
// defined to be the empty string.
|
|
func (c *Client) ProjectAttributeValue(attr string) (string, error) {
|
|
return c.Get("project/attributes/" + attr)
|
|
}
|
|
|
|
// Scopes returns the service account scopes for the given account.
|
|
// The account may be empty or the string "default" to use the instance's
|
|
// main account.
|
|
func (c *Client) Scopes(serviceAccount string) ([]string, error) {
|
|
if serviceAccount == "" {
|
|
serviceAccount = "default"
|
|
}
|
|
return c.lines("instance/service-accounts/" + serviceAccount + "/scopes")
|
|
}
|
|
|
|
// Subscribe subscribes to a value from the metadata service.
|
|
// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
|
|
// The suffix may contain query parameters.
|
|
//
|
|
// Subscribe calls fn with the latest metadata value indicated by the provided
|
|
// suffix. If the metadata value is deleted, fn is called with the empty string
|
|
// and ok false. Subscribe blocks until fn returns a non-nil error or the value
|
|
// is deleted. Subscribe returns the error value returned from the last call to
|
|
// fn, which may be nil when ok == false.
|
|
func (c *Client) Subscribe(suffix string, fn func(v string, ok bool) error) error {
|
|
const failedSubscribeSleep = time.Second * 5
|
|
|
|
// First check to see if the metadata value exists at all.
|
|
val, lastETag, err := c.getETag(suffix)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := fn(val, true); err != nil {
|
|
return err
|
|
}
|
|
|
|
ok := true
|
|
if strings.ContainsRune(suffix, '?') {
|
|
suffix += "&wait_for_change=true&last_etag="
|
|
} else {
|
|
suffix += "?wait_for_change=true&last_etag="
|
|
}
|
|
for {
|
|
val, etag, err := c.getETag(suffix + url.QueryEscape(lastETag))
|
|
if err != nil {
|
|
if _, deleted := err.(NotDefinedError); !deleted {
|
|
time.Sleep(failedSubscribeSleep)
|
|
continue // Retry on other errors.
|
|
}
|
|
ok = false
|
|
}
|
|
lastETag = etag
|
|
|
|
if err := fn(val, ok); err != nil || !ok {
|
|
return err
|
|
}
|
|
}
|
|
}
|