vendor/cloud.google.com/go/compute/metadata/metadata.go - gddo - Git at Google

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // 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 (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"net/url"
 	"os"
 	"runtime"
 	"strings"
 	"sync"
 	"time"

 	"golang.org/x/net/context"
 	"golang.org/x/net/context/ctxhttp"
 )

 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 (
 	metaClient = &http.Client{
 		Transport: &http.Transport{
 			Dial: (&net.Dialer{
 				Timeout:   2 * time.Second,
 				KeepAlive: 30 * time.Second,
 			}).Dial,
 			ResponseHeaderTimeout: 2 * time.Second,
 		},
 	}
 	subscribeClient = &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))
 }

 // 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 Get(suffix string) (string, error) {
 	val, _, err := getETag(metaClient, suffix)
 	return val, err
 }

 // getETag returns a value from the metadata service as well as the associated
 // ETag using the provided client. This func is otherwise equivalent to Get.
 func getETag(client *http.Client, 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 := client.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
 }

 func getTrimmed(suffix string) (s string, err error) {
 	s, err = Get(suffix)
 	s = strings.TrimSpace(s)
 	return
 }

 func (c *cachedValue) get() (v string, err error) {
 	defer c.mu.Unlock()
 	c.mu.Lock()
 	if c.v != "" {
 		return c.v, nil
 	}
 	if c.trim {
 		v, err = getTrimmed(c.k)
 	} else {
 		v, err = 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 := ctxhttp.Do(ctx, metaClient, req)
 		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 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 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 := getETag(subscribeClient, 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 := getETag(subscribeClient, 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
 		}
 	}
 }

 // ProjectID returns the current instance's project ID string.
 func ProjectID() (string, error) { return projID.get() }

 // NumericProjectID returns the current instance's numeric project ID.
 func NumericProjectID() (string, error) { return projNum.get() }

 // InternalIP returns the instance's primary internal IP address.
 func InternalIP() (string, error) {
 	return getTrimmed("instance/network-interfaces/0/ip")
 }

 // ExternalIP returns the instance's primary external (public) IP address.
 func ExternalIP() (string, error) {
 	return 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 Hostname() (string, error) {
 	return getTrimmed("instance/hostname")
 }

 // InstanceTags returns the list of user-defined instance tags,
 // assigned when initially creating a GCE instance.
 func InstanceTags() ([]string, error) {
 	var s []string
 	j, err := 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
 }

 // InstanceID returns the current VM's numeric instance ID.
 func InstanceID() (string, error) {
 	return instID.get()
 }

 // InstanceName returns the current VM's instance ID string.
 func InstanceName() (string, error) {
 	host, err := 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 Zone() (string, error) {
 	zone, err := 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 InstanceAttributes() ([]string, error) { return 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 ProjectAttributes() ([]string, error) { return lines("project/attributes/") }

 func lines(suffix string) ([]string, error) {
 	j, err := 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
 }

 // 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 InstanceAttributeValue(attr string) (string, error) {
 	return 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 ProjectAttributeValue(attr string) (string, error) {
 	return 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 Scopes(serviceAccount string) ([]string, error) {
 	if serviceAccount == "" {
 		serviceAccount = "default"
 	}
 	return lines("instance/service-accounts/" + serviceAccount + "/scopes")
 }

 func strsContains(ss []string, s string) bool {
 	for _, v := range ss {
 		if v == s {
 			return true
 		}
 	}
 	return false
 }
	// Copyright 2014 Google Inc. All Rights Reserved.
	//
	// 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 (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net"
	"net/http"
	"net/url"
	"os"
	"runtime"
	"strings"
	"sync"
	"time"

	"golang.org/x/net/context"
	"golang.org/x/net/context/ctxhttp"
	)

	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 (
	metaClient = &http.Client{
	Transport: &http.Transport{
	Dial: (&net.Dialer{
	Timeout: 2 * time.Second,
	KeepAlive: 30 * time.Second,
	}).Dial,
	ResponseHeaderTimeout: 2 * time.Second,
	},
	}
	subscribeClient = &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))
	}

	// 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 Get(suffix string) (string, error) {
	val, _, err := getETag(metaClient, suffix)
	return val, err
	}

	// getETag returns a value from the metadata service as well as the associated
	// ETag using the provided client. This func is otherwise equivalent to Get.
	func getETag(client *http.Client, 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 := client.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
	}

	func getTrimmed(suffix string) (s string, err error) {
	s, err = Get(suffix)
	s = strings.TrimSpace(s)
	return
	}

	func (c *cachedValue) get() (v string, err error) {
	defer c.mu.Unlock()
	c.mu.Lock()
	if c.v != "" {
	return c.v, nil
	}
	if c.trim {
	v, err = getTrimmed(c.k)
	} else {
	v, err = 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 := ctxhttp.Do(ctx, metaClient, req)
	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 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 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 := getETag(subscribeClient, 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 := getETag(subscribeClient, 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
	}
	}
	}

	// ProjectID returns the current instance's project ID string.
	func ProjectID() (string, error) { return projID.get() }

	// NumericProjectID returns the current instance's numeric project ID.
	func NumericProjectID() (string, error) { return projNum.get() }

	// InternalIP returns the instance's primary internal IP address.
	func InternalIP() (string, error) {
	return getTrimmed("instance/network-interfaces/0/ip")
	}

	// ExternalIP returns the instance's primary external (public) IP address.
	func ExternalIP() (string, error) {
	return 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 Hostname() (string, error) {
	return getTrimmed("instance/hostname")
	}

	// InstanceTags returns the list of user-defined instance tags,
	// assigned when initially creating a GCE instance.
	func InstanceTags() ([]string, error) {
	var s []string
	j, err := 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
	}

	// InstanceID returns the current VM's numeric instance ID.
	func InstanceID() (string, error) {
	return instID.get()
	}

	// InstanceName returns the current VM's instance ID string.
	func InstanceName() (string, error) {
	host, err := 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 Zone() (string, error) {
	zone, err := 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 InstanceAttributes() ([]string, error) { return 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 ProjectAttributes() ([]string, error) { return lines("project/attributes/") }

	func lines(suffix string) ([]string, error) {
	j, err := 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
	}

	// 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 InstanceAttributeValue(attr string) (string, error) {
	return 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 ProjectAttributeValue(attr string) (string, error) {
	return 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 Scopes(serviceAccount string) ([]string, error) {
	if serviceAccount == "" {
	serviceAccount = "default"
	}
	return lines("instance/service-accounts/" + serviceAccount + "/scopes")
	}

	func strsContains(ss []string, s string) bool {
	for _, v := range ss {
	if v == s {
	return true
	}
	}
	return false
	}