add vendoring with go dep

vendor/github.com/vmware/govmomi/govc/flags/client.go

@@ -0,0 +1,602 @@
+/*
+Copyright (c) 2014-2015 VMware, 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 flags
+
+import (
+	"context"
+	"crypto/sha1"
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/vmware/govmomi/session"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+const (
+	envURL           = "GOVC_URL"
+	envUsername      = "GOVC_USERNAME"
+	envPassword      = "GOVC_PASSWORD"
+	envCertificate   = "GOVC_CERTIFICATE"
+	envPrivateKey    = "GOVC_PRIVATE_KEY"
+	envInsecure      = "GOVC_INSECURE"
+	envPersist       = "GOVC_PERSIST_SESSION"
+	envMinAPIVersion = "GOVC_MIN_API_VERSION"
+	envVimNamespace  = "GOVC_VIM_NAMESPACE"
+	envVimVersion    = "GOVC_VIM_VERSION"
+	envTLSCaCerts    = "GOVC_TLS_CA_CERTS"
+	envTLSKnownHosts = "GOVC_TLS_KNOWN_HOSTS"
+)
+
+const cDescr = "ESX or vCenter URL"
+
+type ClientFlag struct {
+	common
+
+	*DebugFlag
+
+	url           *url.URL
+	username      string
+	password      string
+	cert          string
+	key           string
+	insecure      bool
+	persist       bool
+	minAPIVersion string
+	vimNamespace  string
+	vimVersion    string
+	tlsCaCerts    string
+	tlsKnownHosts string
+	tlsHostHash   string
+
+	client *vim25.Client
+}
+
+var (
+	home          = os.Getenv("GOVMOMI_HOME")
+	clientFlagKey = flagKey("client")
+)
+
+func init() {
+	if home == "" {
+		home = filepath.Join(os.Getenv("HOME"), ".govmomi")
+	}
+}
+
+func NewClientFlag(ctx context.Context) (*ClientFlag, context.Context) {
+	if v := ctx.Value(clientFlagKey); v != nil {
+		return v.(*ClientFlag), ctx
+	}
+
+	v := &ClientFlag{}
+	v.DebugFlag, ctx = NewDebugFlag(ctx)
+	ctx = context.WithValue(ctx, clientFlagKey, v)
+	return v, ctx
+}
+
+func (flag *ClientFlag) URLWithoutPassword() *url.URL {
+	if flag.url == nil {
+		return nil
+	}
+
+	withoutCredentials := *flag.url
+	withoutCredentials.User = url.User(flag.url.User.Username())
+	return &withoutCredentials
+}
+
+func (flag *ClientFlag) IsSecure() bool {
+	return !flag.insecure
+}
+
+func (flag *ClientFlag) String() string {
+	url := flag.URLWithoutPassword()
+	if url == nil {
+		return ""
+	}
+
+	return url.String()
+}
+
+func (flag *ClientFlag) Set(s string) error {
+	var err error
+
+	flag.url, err = soap.ParseURL(s)
+
+	return err
+}
+
+func (flag *ClientFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.DebugFlag.Register(ctx, f)
+
+		{
+			flag.Set(os.Getenv(envURL))
+			usage := fmt.Sprintf("%s [%s]", cDescr, envURL)
+			f.Var(flag, "u", usage)
+		}
+
+		{
+			flag.username = os.Getenv(envUsername)
+			flag.password = os.Getenv(envPassword)
+		}
+
+		{
+			value := os.Getenv(envCertificate)
+			usage := fmt.Sprintf("Certificate [%s]", envCertificate)
+			f.StringVar(&flag.cert, "cert", value, usage)
+		}
+
+		{
+			value := os.Getenv(envPrivateKey)
+			usage := fmt.Sprintf("Private key [%s]", envPrivateKey)
+			f.StringVar(&flag.key, "key", value, usage)
+		}
+
+		{
+			insecure := false
+			switch env := strings.ToLower(os.Getenv(envInsecure)); env {
+			case "1", "true":
+				insecure = true
+			}
+
+			usage := fmt.Sprintf("Skip verification of server certificate [%s]", envInsecure)
+			f.BoolVar(&flag.insecure, "k", insecure, usage)
+		}
+
+		{
+			persist := true
+			switch env := strings.ToLower(os.Getenv(envPersist)); env {
+			case "0", "false":
+				persist = false
+			}
+
+			usage := fmt.Sprintf("Persist session to disk [%s]", envPersist)
+			f.BoolVar(&flag.persist, "persist-session", persist, usage)
+		}
+
+		{
+			env := os.Getenv(envMinAPIVersion)
+			if env == "" {
+				env = soap.DefaultMinVimVersion
+			}
+
+			flag.minAPIVersion = env
+		}
+
+		{
+			value := os.Getenv(envVimNamespace)
+			if value == "" {
+				value = soap.DefaultVimNamespace
+			}
+			usage := fmt.Sprintf("Vim namespace [%s]", envVimNamespace)
+			f.StringVar(&flag.vimNamespace, "vim-namespace", value, usage)
+		}
+
+		{
+			value := os.Getenv(envVimVersion)
+			if value == "" {
+				value = soap.DefaultVimVersion
+			}
+			usage := fmt.Sprintf("Vim version [%s]", envVimVersion)
+			f.StringVar(&flag.vimVersion, "vim-version", value, usage)
+		}
+
+		{
+			value := os.Getenv(envTLSCaCerts)
+			usage := fmt.Sprintf("TLS CA certificates file [%s]", envTLSCaCerts)
+			f.StringVar(&flag.tlsCaCerts, "tls-ca-certs", value, usage)
+		}
+
+		{
+			value := os.Getenv(envTLSKnownHosts)
+			usage := fmt.Sprintf("TLS known hosts file [%s]", envTLSKnownHosts)
+			f.StringVar(&flag.tlsKnownHosts, "tls-known-hosts", value, usage)
+		}
+	})
+}
+
+func (flag *ClientFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.DebugFlag.Process(ctx); err != nil {
+			return err
+		}
+
+		if flag.url == nil {
+			return errors.New("specify an " + cDescr)
+		}
+
+		// Override username if set
+		if flag.username != "" {
+			var password string
+			var ok bool
+
+			if flag.url.User != nil {
+				password, ok = flag.url.User.Password()
+			}
+
+			if ok {
+				flag.url.User = url.UserPassword(flag.username, password)
+			} else {
+				flag.url.User = url.User(flag.username)
+			}
+		}
+
+		// Override password if set
+		if flag.password != "" {
+			var username string
+
+			if flag.url.User != nil {
+				username = flag.url.User.Username()
+			}
+
+			flag.url.User = url.UserPassword(username, flag.password)
+		}
+
+		return nil
+	})
+}
+
+// configure TLS and retry settings before making any connections
+func (flag *ClientFlag) configure(sc *soap.Client) (soap.RoundTripper, error) {
+	// Set namespace and version
+	sc.Namespace = flag.vimNamespace
+	sc.Version = flag.vimVersion
+
+	sc.UserAgent = fmt.Sprintf("govc/%s", Version)
+
+	if err := flag.SetRootCAs(sc); err != nil {
+		return nil, err
+	}
+
+	if err := sc.LoadThumbprints(flag.tlsKnownHosts); err != nil {
+		return nil, err
+	}
+
+	// Retry twice when a temporary I/O error occurs.
+	// This means a maximum of 3 attempts.
+	return vim25.Retry(sc, vim25.TemporaryNetworkError(3)), nil
+}
+
+func (flag *ClientFlag) sessionFile() string {
+	url := flag.URLWithoutPassword()
+
+	// Key session file off of full URI and insecure setting.
+	// Hash key to get a predictable, canonical format.
+	key := fmt.Sprintf("%s#insecure=%t", url.String(), flag.insecure)
+	name := fmt.Sprintf("%040x", sha1.Sum([]byte(key)))
+	return filepath.Join(home, "sessions", name)
+}
+
+func (flag *ClientFlag) saveClient(c *vim25.Client) error {
+	if !flag.persist {
+		return nil
+	}
+
+	p := flag.sessionFile()
+	err := os.MkdirAll(filepath.Dir(p), 0700)
+	if err != nil {
+		return err
+	}
+
+	f, err := os.OpenFile(p, os.O_CREATE|os.O_WRONLY, 0600)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	err = json.NewEncoder(f).Encode(c)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (flag *ClientFlag) restoreClient(c *vim25.Client) (bool, error) {
+	if !flag.persist {
+		return false, nil
+	}
+
+	f, err := os.Open(flag.sessionFile())
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+
+		return false, err
+	}
+
+	defer f.Close()
+
+	dec := json.NewDecoder(f)
+	err = dec.Decode(c)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+func (flag *ClientFlag) loadClient() (*vim25.Client, error) {
+	c := new(vim25.Client)
+	ok, err := flag.restoreClient(c)
+	if err != nil {
+		return nil, err
+	}
+
+	if !ok || !c.Valid() {
+		return nil, nil
+	}
+
+	c.RoundTripper, err = flag.configure(c.Client)
+	if err != nil {
+		return nil, err
+	}
+
+	m := session.NewManager(c)
+	u, err := m.UserSession(context.TODO())
+	if err != nil {
+		if soap.IsSoapFault(err) {
+			fault := soap.ToSoapFault(err).VimFault()
+			// If the PropertyCollector is not found, the saved session for this URL is not valid
+			if _, ok := fault.(types.ManagedObjectNotFound); ok {
+				return nil, nil
+			}
+		}
+
+		return nil, err
+	}
+
+	// If the session is nil, the client is not authenticated
+	if u == nil {
+		return nil, nil
+	}
+
+	return c, nil
+}
+
+func (flag *ClientFlag) SetRootCAs(c *soap.Client) error {
+	if flag.tlsCaCerts != "" {
+		return c.SetRootCAs(flag.tlsCaCerts)
+	}
+	return nil
+}
+
+func (flag *ClientFlag) newClient() (*vim25.Client, error) {
+	ctx := context.TODO()
+	sc := soap.NewClient(flag.url, flag.insecure)
+	isTunnel := false
+
+	if flag.cert != "" {
+		isTunnel = true
+		cert, err := tls.LoadX509KeyPair(flag.cert, flag.key)
+		if err != nil {
+			return nil, err
+		}
+
+		sc.SetCertificate(cert)
+	}
+
+	rt, err := flag.configure(sc)
+	if err != nil {
+		return nil, err
+	}
+
+	c, err := vim25.NewClient(ctx, rt)
+	if err != nil {
+		return nil, err
+	}
+
+	// Set client, since we didn't pass it in the constructor
+	c.Client = sc
+
+	m := session.NewManager(c)
+	u := flag.url.User
+
+	if u.Username() == "" {
+		// Assume we are running on an ESX or Workstation host if no username is provided
+		u, err = flag.localTicket(ctx, m)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if isTunnel {
+		err = m.LoginExtensionByCertificate(ctx, u.Username(), "")
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		err = m.Login(ctx, u)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = flag.saveClient(c)
+	if err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func (flag *ClientFlag) localTicket(ctx context.Context, m *session.Manager) (*url.Userinfo, error) {
+	ticket, err := m.AcquireLocalTicket(ctx, os.Getenv("USER"))
+	if err != nil {
+		return nil, err
+	}
+
+	password, err := ioutil.ReadFile(ticket.PasswordFilePath)
+	if err != nil {
+		return nil, err
+	}
+
+	return url.UserPassword(ticket.UserName, string(password)), nil
+}
+
+// apiVersionValid returns whether or not the API version supported by the
+// server the client is connected to is not recent enough.
+func apiVersionValid(c *vim25.Client, minVersionString string) error {
+	if minVersionString == "-" {
+		// Disable version check
+		return nil
+	}
+
+	apiVersion := c.ServiceContent.About.ApiVersion
+	if strings.HasSuffix(apiVersion, ".x") {
+		// Skip version check for development builds
+		return nil
+	}
+
+	realVersion, err := ParseVersion(apiVersion)
+	if err != nil {
+		return err
+	}
+
+	minVersion, err := ParseVersion(minVersionString)
+	if err != nil {
+		return err
+	}
+
+	if !minVersion.Lte(realVersion) {
+		err = fmt.Errorf("Require API version %s, connected to API version %s (set %s to override)",
+			minVersionString,
+			c.ServiceContent.About.ApiVersion,
+			envMinAPIVersion)
+		return err
+	}
+
+	return nil
+}
+
+func (flag *ClientFlag) Client() (*vim25.Client, error) {
+	if flag.client != nil {
+		return flag.client, nil
+	}
+
+	c, err := flag.loadClient()
+	if err != nil {
+		return nil, err
+	}
+
+	// loadClient returns nil if it was unable to load a session from disk
+	if c == nil {
+		c, err = flag.newClient()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Check that the endpoint has the right API version
+	err = apiVersionValid(c, flag.minAPIVersion)
+	if err != nil {
+		return nil, err
+	}
+
+	flag.client = c
+	return flag.client, nil
+}
+
+func (flag *ClientFlag) Logout(ctx context.Context) error {
+	if flag.persist || flag.client == nil {
+		return nil
+	}
+
+	m := session.NewManager(flag.client)
+
+	return m.Logout(ctx)
+}
+
+// Environ returns the govc environment variables for this connection
+func (flag *ClientFlag) Environ(extra bool) []string {
+	var env []string
+	add := func(k, v string) {
+		env = append(env, fmt.Sprintf("%s=%s", k, v))
+	}
+
+	u := *flag.url
+	if u.User != nil {
+		add(envUsername, u.User.Username())
+
+		if p, ok := u.User.Password(); ok {
+			add(envPassword, p)
+		}
+
+		u.User = nil
+	}
+
+	if u.Path == "/sdk" {
+		u.Path = ""
+	}
+	u.Fragment = ""
+	u.RawQuery = ""
+
+	val := u.String()
+	prefix := "https://"
+	if strings.HasPrefix(val, prefix) {
+		val = val[len(prefix):]
+	}
+	add(envURL, val)
+
+	keys := []string{
+		envCertificate,
+		envPrivateKey,
+		envInsecure,
+		envPersist,
+		envMinAPIVersion,
+		envVimNamespace,
+		envVimVersion,
+	}
+
+	for _, k := range keys {
+		if v := os.Getenv(k); v != "" {
+			add(k, v)
+		}
+	}
+
+	if extra {
+		add("GOVC_URL_SCHEME", flag.url.Scheme)
+
+		v := strings.SplitN(u.Host, ":", 2)
+		add("GOVC_URL_HOST", v[0])
+		if len(v) == 2 {
+			add("GOVC_URL_PORT", v[1])
+		}
+
+		add("GOVC_URL_PATH", flag.url.Path)
+
+		if f := flag.url.Fragment; f != "" {
+			add("GOVC_URL_FRAGMENT", f)
+		}
+
+		if q := flag.url.RawQuery; q != "" {
+			add("GOVC_URL_QUERY", q)
+		}
+	}
+
+	return env
+}

vendor/github.com/vmware/govmomi/govc/flags/common.go

@@ -0,0 +1,38 @@
+/*
+Copyright (c) 2015-2016 VMware, 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 flags
+
+import "sync"
+
+// Key type for storing flag instances in a context.Context.
+type flagKey string
+
+// Type to help flags out with only registering/processing once.
+type common struct {
+	register sync.Once
+	process  sync.Once
+}
+
+func (c *common) RegisterOnce(fn func()) {
+	c.register.Do(fn)
+}
+
+func (c *common) ProcessOnce(fn func() error) (err error) {
+	c.process.Do(func() {
+		err = fn()
+	})
+	return err
+}

vendor/github.com/vmware/govmomi/govc/flags/datacenter.go

@@ -0,0 +1,170 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/find"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DatacenterFlag struct {
+	common
+
+	*ClientFlag
+	*OutputFlag
+
+	path   string
+	dc     *object.Datacenter
+	finder *find.Finder
+	err    error
+}
+
+var datacenterFlagKey = flagKey("datacenter")
+
+func NewDatacenterFlag(ctx context.Context) (*DatacenterFlag, context.Context) {
+	if v := ctx.Value(datacenterFlagKey); v != nil {
+		return v.(*DatacenterFlag), ctx
+	}
+
+	v := &DatacenterFlag{}
+	v.ClientFlag, ctx = NewClientFlag(ctx)
+	v.OutputFlag, ctx = NewOutputFlag(ctx)
+	ctx = context.WithValue(ctx, datacenterFlagKey, v)
+	return v, ctx
+}
+
+func (flag *DatacenterFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.ClientFlag.Register(ctx, f)
+		flag.OutputFlag.Register(ctx, f)
+
+		env := "GOVC_DATACENTER"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Datacenter [%s]", env)
+		f.StringVar(&flag.path, "dc", value, usage)
+	})
+}
+
+func (flag *DatacenterFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.ClientFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.OutputFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *DatacenterFlag) Finder() (*find.Finder, error) {
+	if flag.finder != nil {
+		return flag.finder, nil
+	}
+
+	c, err := flag.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	finder := find.NewFinder(c, flag.JSON || flag.Dump)
+
+	// Datacenter is not required (ls command for example).
+	// Set for relative func if dc flag is given or
+	// if there is a single (default) Datacenter
+	ctx := context.TODO()
+	if flag.path == "" {
+		flag.dc, flag.err = finder.DefaultDatacenter(ctx)
+	} else {
+		if flag.dc, err = finder.Datacenter(ctx, flag.path); err != nil {
+			return nil, err
+		}
+	}
+
+	finder.SetDatacenter(flag.dc)
+
+	flag.finder = finder
+
+	return flag.finder, nil
+}
+
+func (flag *DatacenterFlag) Datacenter() (*object.Datacenter, error) {
+	if flag.dc != nil {
+		return flag.dc, nil
+	}
+
+	_, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	if flag.err != nil {
+		// Should only happen if no dc is specified and len(dcs) > 1
+		return nil, flag.err
+	}
+
+	return flag.dc, err
+}
+
+func (flag *DatacenterFlag) DatacenterIfSpecified() (*object.Datacenter, error) {
+	if flag.path == "" {
+		return nil, nil
+	}
+	return flag.Datacenter()
+}
+
+func (flag *DatacenterFlag) ManagedObjects(ctx context.Context, args []string) ([]types.ManagedObjectReference, error) {
+	var refs []types.ManagedObjectReference
+
+	c, err := flag.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	if len(args) == 0 {
+		refs = append(refs, c.ServiceContent.RootFolder)
+		return refs, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, arg := range args {
+		elements, err := finder.ManagedObjectList(ctx, arg)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(elements) == 0 {
+			return nil, fmt.Errorf("object '%s' not found", arg)
+		}
+
+		for _, e := range elements {
+			refs = append(refs, e.Object.Reference())
+		}
+	}
+
+	return refs, nil
+}

vendor/github.com/vmware/govmomi/govc/flags/datastore.go

@@ -0,0 +1,120 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DatastoreFlag struct {
+	common
+
+	*DatacenterFlag
+
+	Name string
+
+	ds *object.Datastore
+}
+
+var datastoreFlagKey = flagKey("datastore")
+
+// NewCustomDatastoreFlag creates and returns a new DatastoreFlag without
+// trying to retrieve an existing one from the specified context.
+func NewCustomDatastoreFlag(ctx context.Context) (*DatastoreFlag, context.Context) {
+	v := &DatastoreFlag{}
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	return v, ctx
+}
+
+func NewDatastoreFlag(ctx context.Context) (*DatastoreFlag, context.Context) {
+	if v := ctx.Value(datastoreFlagKey); v != nil {
+		return v.(*DatastoreFlag), ctx
+	}
+
+	v, ctx := NewCustomDatastoreFlag(ctx)
+	ctx = context.WithValue(ctx, datastoreFlagKey, v)
+	return v, ctx
+}
+
+func (f *DatastoreFlag) Register(ctx context.Context, fs *flag.FlagSet) {
+	f.RegisterOnce(func() {
+		f.DatacenterFlag.Register(ctx, fs)
+
+		env := "GOVC_DATASTORE"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Datastore [%s]", env)
+		fs.StringVar(&f.Name, "ds", value, usage)
+	})
+}
+
+func (f *DatastoreFlag) Process(ctx context.Context) error {
+	return f.ProcessOnce(func() error {
+		if err := f.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (f *DatastoreFlag) Datastore() (*object.Datastore, error) {
+	if f.ds != nil {
+		return f.ds, nil
+	}
+
+	finder, err := f.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	if f.ds, err = finder.DatastoreOrDefault(context.TODO(), f.Name); err != nil {
+		return nil, err
+	}
+
+	return f.ds, nil
+}
+
+func (flag *DatastoreFlag) DatastoreIfSpecified() (*object.Datastore, error) {
+	if flag.Name == "" {
+		return nil, nil
+	}
+	return flag.Datastore()
+}
+
+func (f *DatastoreFlag) DatastorePath(name string) (string, error) {
+	ds, err := f.Datastore()
+	if err != nil {
+		return "", err
+	}
+
+	return ds.Path(name), nil
+}
+
+func (f *DatastoreFlag) Stat(ctx context.Context, file string) (types.BaseFileInfo, error) {
+	ds, err := f.Datastore()
+	if err != nil {
+		return nil, err
+	}
+
+	return ds.Stat(ctx, file)
+
+}

vendor/github.com/vmware/govmomi/govc/flags/debug.go

@@ -0,0 +1,99 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/debug"
+)
+
+type DebugFlag struct {
+	common
+
+	enable bool
+}
+
+var debugFlagKey = flagKey("debug")
+
+func NewDebugFlag(ctx context.Context) (*DebugFlag, context.Context) {
+	if v := ctx.Value(debugFlagKey); v != nil {
+		return v.(*DebugFlag), ctx
+	}
+
+	v := &DebugFlag{}
+	ctx = context.WithValue(ctx, debugFlagKey, v)
+	return v, ctx
+}
+
+func (flag *DebugFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		env := "GOVC_DEBUG"
+		enable := false
+		switch env := strings.ToLower(os.Getenv(env)); env {
+		case "1", "true":
+			enable = true
+		}
+
+		usage := fmt.Sprintf("Store debug logs [%s]", env)
+		f.BoolVar(&flag.enable, "debug", enable, usage)
+	})
+}
+
+func (flag *DebugFlag) Process(ctx context.Context) error {
+	if !flag.enable {
+		return nil
+	}
+
+	return flag.ProcessOnce(func() error {
+		// Base path for storing debug logs.
+		r := os.Getenv("GOVC_DEBUG_PATH")
+		if r == "" {
+			r = home
+		}
+		r = filepath.Join(r, "debug")
+
+		// Path for this particular run.
+		run := os.Getenv("GOVC_DEBUG_PATH_RUN")
+		if run == "" {
+			now := time.Now().Format("2006-01-02T15-04-05.999999999")
+			r = filepath.Join(r, now)
+		} else {
+			// reuse the same path
+			r = filepath.Join(r, run)
+			_ = os.RemoveAll(r)
+		}
+
+		err := os.MkdirAll(r, 0700)
+		if err != nil {
+			return err
+		}
+
+		p := debug.FileProvider{
+			Path: r,
+		}
+
+		debug.SetProvider(&p)
+		return nil
+	})
+}

vendor/github.com/vmware/govmomi/govc/flags/empty.go

@@ -0,0 +1,31 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+)
+
+type EmptyFlag struct{}
+
+func (flag *EmptyFlag) Register(ctx context.Context, f *flag.FlagSet) {
+}
+
+func (flag *EmptyFlag) Process(ctx context.Context) error {
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/flags/folder.go

@@ -0,0 +1,131 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+)
+
+type FolderFlag struct {
+	common
+
+	*DatacenterFlag
+
+	name   string
+	folder *object.Folder
+}
+
+var folderFlagKey = flagKey("folder")
+
+func NewFolderFlag(ctx context.Context) (*FolderFlag, context.Context) {
+	if v := ctx.Value(folderFlagKey); v != nil {
+		return v.(*FolderFlag), ctx
+	}
+
+	v := &FolderFlag{}
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	ctx = context.WithValue(ctx, folderFlagKey, v)
+	return v, ctx
+}
+
+func (flag *FolderFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.DatacenterFlag.Register(ctx, f)
+
+		env := "GOVC_FOLDER"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Inventory folder [%s]", env)
+		f.StringVar(&flag.name, "folder", value, usage)
+	})
+}
+
+func (flag *FolderFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *FolderFlag) Folder() (*object.Folder, error) {
+	if flag.folder != nil {
+		return flag.folder, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	if flag.folder, err = finder.FolderOrDefault(context.TODO(), flag.name); err != nil {
+		return nil, err
+	}
+
+	return flag.folder, nil
+}
+
+func (flag *FolderFlag) FolderOrDefault(kind string) (*object.Folder, error) {
+	if flag.folder != nil {
+		return flag.folder, nil
+	}
+
+	if flag.name != "" {
+		return flag.Folder()
+	}
+
+	// RootFolder, no dc required
+	if kind == "/" {
+		client, err := flag.Client()
+		if err != nil {
+			return nil, err
+		}
+
+		flag.folder = object.NewRootFolder(client)
+		return flag.folder, nil
+	}
+
+	dc, err := flag.Datacenter()
+	if err != nil {
+		return nil, err
+	}
+
+	folders, err := dc.Folders(context.TODO())
+	if err != nil {
+		return nil, err
+	}
+
+	switch kind {
+	case "vm":
+		flag.folder = folders.VmFolder
+	case "host":
+		flag.folder = folders.HostFolder
+	case "datastore":
+		flag.folder = folders.DatastoreFolder
+	case "network":
+		flag.folder = folders.NetworkFolder
+	default:
+		panic(kind)
+	}
+
+	return flag.folder, nil
+}

vendor/github.com/vmware/govmomi/govc/flags/host_connect.go

@@ -0,0 +1,101 @@
+/*
+Copyright (c) 2015 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostConnectFlag struct {
+	common
+
+	types.HostConnectSpec
+
+	noverify bool
+}
+
+var hostConnectFlagKey = flagKey("hostConnect")
+
+func NewHostConnectFlag(ctx context.Context) (*HostConnectFlag, context.Context) {
+	if v := ctx.Value(hostConnectFlagKey); v != nil {
+		return v.(*HostConnectFlag), ctx
+	}
+
+	v := &HostConnectFlag{}
+	ctx = context.WithValue(ctx, hostConnectFlagKey, v)
+	return v, ctx
+}
+
+func (flag *HostConnectFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		f.StringVar(&flag.HostName, "hostname", "", "Hostname or IP address of the host")
+		f.StringVar(&flag.UserName, "username", "", "Username of administration account on the host")
+		f.StringVar(&flag.Password, "password", "", "Password of administration account on the host")
+		f.StringVar(&flag.SslThumbprint, "thumbprint", "", "SHA-1 thumbprint of the host's SSL certificate")
+		f.BoolVar(&flag.Force, "force", false, "Force when host is managed by another VC")
+
+		f.BoolVar(&flag.noverify, "noverify", false, "Accept host thumbprint without verification")
+	})
+}
+
+func (flag *HostConnectFlag) Process(ctx context.Context) error {
+	return nil
+}
+
+// Spec attempts to fill in SslThumbprint if empty.
+// First checks GOVC_TLS_KNOWN_HOSTS, if not found and noverify=true then
+// use object.HostCertificateInfo to get the thumbprint.
+func (flag *HostConnectFlag) Spec(c *vim25.Client) types.HostConnectSpec {
+	spec := flag.HostConnectSpec
+
+	if spec.SslThumbprint == "" {
+		spec.SslThumbprint = c.Thumbprint(spec.HostName)
+
+		if spec.SslThumbprint == "" && flag.noverify {
+			var info object.HostCertificateInfo
+			t := c.Transport.(*http.Transport)
+			_ = info.FromURL(&url.URL{Host: spec.HostName}, t.TLSClientConfig)
+			spec.SslThumbprint = info.ThumbprintSHA1
+		}
+	}
+
+	return spec
+}
+
+// Fault checks if error is SSLVerifyFault, including the thumbprint if so
+func (flag *HostConnectFlag) Fault(err error) error {
+	if err == nil {
+		return nil
+	}
+
+	if f, ok := err.(types.HasFault); ok {
+		switch fault := f.Fault().(type) {
+		case *types.SSLVerifyFault:
+			return fmt.Errorf("%s thumbprint=%s", err, fault.Thumbprint)
+		}
+	}
+
+	return err
+}

vendor/github.com/vmware/govmomi/govc/flags/host_system.go

@@ -0,0 +1,141 @@
+/*
+Copyright (c) 2014-2015 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+)
+
+type HostSystemFlag struct {
+	common
+
+	*ClientFlag
+	*DatacenterFlag
+	*SearchFlag
+
+	name string
+	host *object.HostSystem
+	pool *object.ResourcePool
+}
+
+var hostSystemFlagKey = flagKey("hostSystem")
+
+func NewHostSystemFlag(ctx context.Context) (*HostSystemFlag, context.Context) {
+	if v := ctx.Value(hostSystemFlagKey); v != nil {
+		return v.(*HostSystemFlag), ctx
+	}
+
+	v := &HostSystemFlag{}
+	v.ClientFlag, ctx = NewClientFlag(ctx)
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	v.SearchFlag, ctx = NewSearchFlag(ctx, SearchHosts)
+	ctx = context.WithValue(ctx, hostSystemFlagKey, v)
+	return v, ctx
+}
+
+func (flag *HostSystemFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.ClientFlag.Register(ctx, f)
+		flag.DatacenterFlag.Register(ctx, f)
+		flag.SearchFlag.Register(ctx, f)
+
+		env := "GOVC_HOST"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Host system [%s]", env)
+		f.StringVar(&flag.name, "host", value, usage)
+	})
+}
+
+func (flag *HostSystemFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.ClientFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.SearchFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *HostSystemFlag) HostSystemIfSpecified() (*object.HostSystem, error) {
+	if flag.host != nil {
+		return flag.host, nil
+	}
+
+	// Use search flags if specified.
+	if flag.SearchFlag.IsSet() {
+		host, err := flag.SearchFlag.HostSystem()
+		if err != nil {
+			return nil, err
+		}
+
+		flag.host = host
+		return flag.host, nil
+	}
+
+	// Never look for a default host system.
+	// A host system parameter is optional for vm creation. It uses a mandatory
+	// resource pool parameter to determine where the vm should be placed.
+	if flag.name == "" {
+		return nil, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	flag.host, err = finder.HostSystem(context.TODO(), flag.name)
+	return flag.host, err
+}
+
+func (flag *HostSystemFlag) HostSystem() (*object.HostSystem, error) {
+	host, err := flag.HostSystemIfSpecified()
+	if err != nil {
+		return nil, err
+	}
+
+	if host != nil {
+		return host, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	flag.host, err = finder.DefaultHostSystem(context.TODO())
+	return flag.host, err
+}
+
+func (flag *HostSystemFlag) HostNetworkSystem() (*object.HostNetworkSystem, error) {
+	host, err := flag.HostSystem()
+	if err != nil {
+		return nil, err
+	}
+
+	return host.ConfigManager().NetworkSystem(context.TODO())
+}

vendor/github.com/vmware/govmomi/govc/flags/int32.go

@@ -0,0 +1,72 @@
+/*
+Copyright (c) 2016-2017 VMware, 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 flags
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+)
+
+// This flag type is internal to stdlib:
+// https://github.com/golang/go/blob/master/src/cmd/internal/obj/flag.go
+type int32Value int32
+
+func (i *int32Value) Set(s string) error {
+	v, err := strconv.ParseInt(s, 0, 32)
+	*i = int32Value(v)
+	return err
+}
+
+func (i *int32Value) Get() interface{} {
+	return int32(*i)
+}
+
+func (i *int32Value) String() string {
+	return fmt.Sprintf("%v", *i)
+}
+
+// NewInt32 behaves as flag.IntVar, but using an int32 type.
+func NewInt32(v *int32) flag.Value {
+	return (*int32Value)(v)
+}
+
+type int32ptrValue struct {
+	val **int32
+}
+
+func (i *int32ptrValue) Set(s string) error {
+	v, err := strconv.ParseInt(s, 0, 32)
+	*i.val = new(int32)
+	**i.val = int32(v)
+	return err
+}
+
+func (i *int32ptrValue) Get() interface{} {
+	if i.val == nil {
+		return -1
+	}
+	return *i.val
+}
+
+func (i *int32ptrValue) String() string {
+	return fmt.Sprintf("%v", i.Get())
+}
+
+func NewOptionalInt32(v **int32) flag.Value {
+	return &int32ptrValue{val: v}
+}

vendor/github.com/vmware/govmomi/govc/flags/network.go

@@ -0,0 +1,131 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type NetworkFlag struct {
+	common
+
+	*DatacenterFlag
+
+	name    string
+	net     object.NetworkReference
+	adapter string
+	address string
+	isset   bool
+}
+
+var networkFlagKey = flagKey("network")
+
+func NewNetworkFlag(ctx context.Context) (*NetworkFlag, context.Context) {
+	if v := ctx.Value(networkFlagKey); v != nil {
+		return v.(*NetworkFlag), ctx
+	}
+
+	v := &NetworkFlag{}
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	ctx = context.WithValue(ctx, networkFlagKey, v)
+	return v, ctx
+}
+
+func (flag *NetworkFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.DatacenterFlag.Register(ctx, f)
+
+		env := "GOVC_NETWORK"
+		value := os.Getenv(env)
+		flag.name = value
+		usage := fmt.Sprintf("Network [%s]", env)
+		f.Var(flag, "net", usage)
+		f.StringVar(&flag.adapter, "net.adapter", "e1000", "Network adapter type")
+		f.StringVar(&flag.address, "net.address", "", "Network hardware address")
+	})
+}
+
+func (flag *NetworkFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *NetworkFlag) String() string {
+	return flag.name
+}
+
+func (flag *NetworkFlag) Set(name string) error {
+	flag.name = name
+	flag.isset = true
+	return nil
+}
+
+func (flag *NetworkFlag) IsSet() bool {
+	return flag.isset
+}
+
+func (flag *NetworkFlag) Network() (object.NetworkReference, error) {
+	if flag.net != nil {
+		return flag.net, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	if flag.net, err = finder.NetworkOrDefault(context.TODO(), flag.name); err != nil {
+		return nil, err
+	}
+
+	return flag.net, nil
+}
+
+func (flag *NetworkFlag) Device() (types.BaseVirtualDevice, error) {
+	net, err := flag.Network()
+	if err != nil {
+		return nil, err
+	}
+
+	backing, err := net.EthernetCardBackingInfo(context.TODO())
+	if err != nil {
+		return nil, err
+	}
+
+	device, err := object.EthernetCardTypes().CreateEthernetCard(flag.adapter, backing)
+	if err != nil {
+		return nil, err
+	}
+
+	if flag.address != "" {
+		card := device.(types.BaseVirtualEthernetCard).GetVirtualEthernetCard()
+		card.AddressType = string(types.VirtualEthernetCardMacTypeManual)
+		card.MacAddress = flag.address
+	}
+
+	return device, nil
+}

vendor/github.com/vmware/govmomi/govc/flags/optional_bool.go

@@ -0,0 +1,55 @@
+/*
+Copyright (c) 2015 VMware, 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 flags
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+)
+
+type optionalBool struct {
+	val **bool
+}
+
+func (b *optionalBool) Set(s string) error {
+	v, err := strconv.ParseBool(s)
+	*b.val = &v
+	return err
+}
+
+func (b *optionalBool) Get() interface{} {
+	if *b.val == nil {
+		return nil
+	}
+	return **b.val
+}
+
+func (b *optionalBool) String() string {
+	if b.val == nil || *b.val == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("%v", **b.val)
+}
+
+func (b *optionalBool) IsBoolFlag() bool { return true }
+
+// NewOptionalBool returns a flag.Value implementation where there is no default value.
+// This avoids sending a default value over the wire as using flag.BoolVar() would.
+func NewOptionalBool(v **bool) flag.Value {
+	return &optionalBool{v}
+}

vendor/github.com/vmware/govmomi/govc/flags/optional_bool_test.go

@@ -0,0 +1,71 @@
+/*
+Copyright (c) 2015 VMware, 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 flags
+
+import (
+	"flag"
+	"testing"
+)
+
+func TestOptionalBool(t *testing.T) {
+	fs := flag.NewFlagSet("", flag.ContinueOnError)
+	var val *bool
+
+	fs.Var(NewOptionalBool(&val), "obool", "optional bool")
+
+	b := fs.Lookup("obool")
+
+	if b.DefValue != "<nil>" {
+		t.Fail()
+	}
+
+	if b.Value.String() != "<nil>" {
+		t.Fail()
+	}
+
+	if b.Value.(flag.Getter).Get() != nil {
+		t.Fail()
+	}
+
+	b.Value.Set("true")
+
+	if b.Value.String() != "true" {
+		t.Fail()
+	}
+
+	if b.Value.(flag.Getter).Get() != true {
+		t.Fail()
+	}
+
+	if val == nil || *val != true {
+		t.Fail()
+	}
+
+	b.Value.Set("false")
+
+	if b.Value.String() != "false" {
+		t.Fail()
+	}
+
+	if b.Value.(flag.Getter).Get() != false {
+		t.Fail()
+	}
+
+	if val == nil || *val != false {
+		t.Fail()
+	}
+}

vendor/github.com/vmware/govmomi/govc/flags/output.go

@@ -0,0 +1,216 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/progress"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+type OutputWriter interface {
+	Write(io.Writer) error
+}
+
+type OutputFlag struct {
+	common
+
+	JSON bool
+	TTY  bool
+	Dump bool
+	Out  io.Writer
+}
+
+var outputFlagKey = flagKey("output")
+
+func NewOutputFlag(ctx context.Context) (*OutputFlag, context.Context) {
+	if v := ctx.Value(outputFlagKey); v != nil {
+		return v.(*OutputFlag), ctx
+	}
+
+	v := &OutputFlag{Out: os.Stdout}
+	ctx = context.WithValue(ctx, outputFlagKey, v)
+	return v, ctx
+}
+
+func (flag *OutputFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		f.BoolVar(&flag.JSON, "json", false, "Enable JSON output")
+		f.BoolVar(&flag.Dump, "dump", false, "Enable output dump")
+	})
+}
+
+func (flag *OutputFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if !flag.JSON {
+			// Assume we have a tty if not outputting JSON
+			flag.TTY = true
+		}
+
+		return nil
+	})
+}
+
+// Log outputs the specified string, prefixed with the current time.
+// A newline is not automatically added. If the specified string
+// starts with a '\r', the current line is cleared first.
+func (flag *OutputFlag) Log(s string) (int, error) {
+	if len(s) > 0 && s[0] == '\r' {
+		flag.Write([]byte{'\r', 033, '[', 'K'})
+		s = s[1:]
+	}
+
+	return flag.WriteString(time.Now().Format("[02-01-06 15:04:05] ") + s)
+}
+
+func (flag *OutputFlag) Write(b []byte) (int, error) {
+	if !flag.TTY {
+		return 0, nil
+	}
+
+	n, err := os.Stdout.Write(b)
+	os.Stdout.Sync()
+	return n, err
+}
+
+func (flag *OutputFlag) WriteString(s string) (int, error) {
+	return flag.Write([]byte(s))
+}
+
+func (flag *OutputFlag) WriteResult(result OutputWriter) error {
+	var err error
+
+	if flag.JSON {
+		err = json.NewEncoder(flag.Out).Encode(result)
+	} else if flag.Dump {
+		scs := spew.ConfigState{Indent: "    "}
+		scs.Fdump(flag.Out, result)
+	} else {
+		err = result.Write(flag.Out)
+	}
+
+	return err
+}
+
+type progressLogger struct {
+	flag   *OutputFlag
+	prefix string
+
+	wg sync.WaitGroup
+
+	sink chan chan progress.Report
+	done chan struct{}
+}
+
+func newProgressLogger(flag *OutputFlag, prefix string) *progressLogger {
+	p := &progressLogger{
+		flag:   flag,
+		prefix: prefix,
+
+		sink: make(chan chan progress.Report),
+		done: make(chan struct{}),
+	}
+
+	p.wg.Add(1)
+
+	go p.loopA()
+
+	return p
+}
+
+// loopA runs before Sink() has been called.
+func (p *progressLogger) loopA() {
+	var err error
+
+	defer p.wg.Done()
+
+	tick := time.NewTicker(100 * time.Millisecond)
+	defer tick.Stop()
+
+	for stop := false; !stop; {
+		select {
+		case ch := <-p.sink:
+			err = p.loopB(tick, ch)
+			stop = true
+		case <-p.done:
+			stop = true
+		case <-tick.C:
+			line := fmt.Sprintf("\r%s", p.prefix)
+			p.flag.Log(line)
+		}
+	}
+
+	if err != nil && err != io.EOF {
+		p.flag.Log(fmt.Sprintf("\r%sError: %s\n", p.prefix, err))
+	} else {
+		p.flag.Log(fmt.Sprintf("\r%sOK\n", p.prefix))
+	}
+}
+
+// loopA runs after Sink() has been called.
+func (p *progressLogger) loopB(tick *time.Ticker, ch <-chan progress.Report) error {
+	var r progress.Report
+	var ok bool
+	var err error
+
+	for ok = true; ok; {
+		select {
+		case r, ok = <-ch:
+			if !ok {
+				break
+			}
+			err = r.Error()
+		case <-tick.C:
+			line := fmt.Sprintf("\r%s", p.prefix)
+			if r != nil {
+				line += fmt.Sprintf("(%.0f%%", r.Percentage())
+				detail := r.Detail()
+				if detail != "" {
+					line += fmt.Sprintf(", %s", detail)
+				}
+				line += ")"
+			}
+			p.flag.Log(line)
+		}
+	}
+
+	return err
+}
+
+func (p *progressLogger) Sink() chan<- progress.Report {
+	ch := make(chan progress.Report)
+	p.sink <- ch
+	return ch
+}
+
+func (p *progressLogger) Wait() {
+	close(p.done)
+	p.wg.Wait()
+}
+
+func (flag *OutputFlag) ProgressLogger(prefix string) *progressLogger {
+	return newProgressLogger(flag, prefix)
+}

vendor/github.com/vmware/govmomi/govc/flags/resource_pool.go

@@ -0,0 +1,92 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+)
+
+type ResourcePoolFlag struct {
+	common
+
+	*DatacenterFlag
+
+	name string
+	pool *object.ResourcePool
+}
+
+var resourcePoolFlagKey = flagKey("resourcePool")
+
+func NewResourcePoolFlag(ctx context.Context) (*ResourcePoolFlag, context.Context) {
+	if v := ctx.Value(resourcePoolFlagKey); v != nil {
+		return v.(*ResourcePoolFlag), ctx
+	}
+
+	v := &ResourcePoolFlag{}
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	ctx = context.WithValue(ctx, resourcePoolFlagKey, v)
+	return v, ctx
+}
+
+func (flag *ResourcePoolFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.DatacenterFlag.Register(ctx, f)
+
+		env := "GOVC_RESOURCE_POOL"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Resource pool [%s]", env)
+		f.StringVar(&flag.name, "pool", value, usage)
+	})
+}
+
+func (flag *ResourcePoolFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *ResourcePoolFlag) ResourcePool() (*object.ResourcePool, error) {
+	if flag.pool != nil {
+		return flag.pool, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	if flag.pool, err = finder.ResourcePoolOrDefault(context.TODO(), flag.name); err != nil {
+		return nil, err
+	}
+
+	return flag.pool, nil
+}
+
+func (flag *ResourcePoolFlag) ResourcePoolIfSpecified() (*object.ResourcePool, error) {
+	if flag.name == "" {
+		return nil, nil
+	}
+	return flag.ResourcePool()
+}

vendor/github.com/vmware/govmomi/govc/flags/search.go

@@ -0,0 +1,434 @@
+/*
+Copyright (c) 2014-2016 VMware, 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 flags
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/vmware/govmomi/find"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+const (
+	SearchVirtualMachines = iota + 1
+	SearchHosts
+	SearchVirtualApps
+)
+
+type SearchFlag struct {
+	common
+
+	*ClientFlag
+	*DatacenterFlag
+
+	t      int
+	entity string
+
+	byDatastorePath string
+	byDNSName       string
+	byInventoryPath string
+	byIP            string
+	byUUID          string
+
+	isset bool
+}
+
+var searchFlagKey = flagKey("search")
+
+func NewSearchFlag(ctx context.Context, t int) (*SearchFlag, context.Context) {
+	if v := ctx.Value(searchFlagKey); v != nil {
+		return v.(*SearchFlag), ctx
+	}
+
+	v := &SearchFlag{
+		t: t,
+	}
+
+	v.ClientFlag, ctx = NewClientFlag(ctx)
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+
+	switch t {
+	case SearchVirtualMachines:
+		v.entity = "VM"
+	case SearchHosts:
+		v.entity = "host"
+	case SearchVirtualApps:
+		v.entity = "vapp"
+	default:
+		panic("invalid search type")
+	}
+
+	ctx = context.WithValue(ctx, searchFlagKey, v)
+	return v, ctx
+}
+
+func (flag *SearchFlag) Register(ctx context.Context, fs *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.ClientFlag.Register(ctx, fs)
+		flag.DatacenterFlag.Register(ctx, fs)
+
+		register := func(v *string, f string, d string) {
+			f = fmt.Sprintf("%s.%s", strings.ToLower(flag.entity), f)
+			d = fmt.Sprintf(d, flag.entity)
+			fs.StringVar(v, f, "", d)
+		}
+
+		switch flag.t {
+		case SearchVirtualMachines:
+			register(&flag.byDatastorePath, "path", "Find %s by path to .vmx file")
+		}
+
+		switch flag.t {
+		case SearchVirtualMachines, SearchHosts:
+			register(&flag.byDNSName, "dns", "Find %s by FQDN")
+			register(&flag.byIP, "ip", "Find %s by IP address")
+			register(&flag.byUUID, "uuid", "Find %s by UUID")
+		}
+
+		register(&flag.byInventoryPath, "ipath", "Find %s by inventory path")
+	})
+}
+
+func (flag *SearchFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.ClientFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+
+		flags := []string{
+			flag.byDatastorePath,
+			flag.byDNSName,
+			flag.byInventoryPath,
+			flag.byIP,
+			flag.byUUID,
+		}
+
+		flag.isset = false
+		for _, f := range flags {
+			if f != "" {
+				if flag.isset {
+					return errors.New("cannot use more than one search flag")
+				}
+				flag.isset = true
+			}
+		}
+
+		return nil
+	})
+}
+
+func (flag *SearchFlag) IsSet() bool {
+	return flag.isset
+}
+
+func (flag *SearchFlag) searchIndex(c *vim25.Client) *object.SearchIndex {
+	return object.NewSearchIndex(c)
+}
+
+func (flag *SearchFlag) searchByDatastorePath(c *vim25.Client, dc *object.Datacenter) (object.Reference, error) {
+	ctx := context.TODO()
+	switch flag.t {
+	case SearchVirtualMachines:
+		return flag.searchIndex(c).FindByDatastorePath(ctx, dc, flag.byDatastorePath)
+	default:
+		panic("unsupported type")
+	}
+}
+
+func (flag *SearchFlag) searchByDNSName(c *vim25.Client, dc *object.Datacenter) (object.Reference, error) {
+	ctx := context.TODO()
+	switch flag.t {
+	case SearchVirtualMachines:
+		return flag.searchIndex(c).FindByDnsName(ctx, dc, flag.byDNSName, true)
+	case SearchHosts:
+		return flag.searchIndex(c).FindByDnsName(ctx, dc, flag.byDNSName, false)
+	default:
+		panic("unsupported type")
+	}
+}
+
+func (flag *SearchFlag) searchByInventoryPath(c *vim25.Client, dc *object.Datacenter) (object.Reference, error) {
+	// TODO(PN): The datacenter flag should not be set because it is ignored.
+	ctx := context.TODO()
+	return flag.searchIndex(c).FindByInventoryPath(ctx, flag.byInventoryPath)
+}
+
+func (flag *SearchFlag) searchByIP(c *vim25.Client, dc *object.Datacenter) (object.Reference, error) {
+	ctx := context.TODO()
+	switch flag.t {
+	case SearchVirtualMachines:
+		return flag.searchIndex(c).FindByIp(ctx, dc, flag.byIP, true)
+	case SearchHosts:
+		return flag.searchIndex(c).FindByIp(ctx, dc, flag.byIP, false)
+	default:
+		panic("unsupported type")
+	}
+}
+
+func (flag *SearchFlag) searchByUUID(c *vim25.Client, dc *object.Datacenter) (object.Reference, error) {
+	ctx := context.TODO()
+	isVM := false
+	switch flag.t {
+	case SearchVirtualMachines:
+		isVM = true
+	case SearchHosts:
+	default:
+		panic("unsupported type")
+	}
+
+	var ref object.Reference
+	var err error
+
+	for _, iu := range []*bool{nil, types.NewBool(true)} {
+		ref, err = flag.searchIndex(c).FindByUuid(ctx, dc, flag.byUUID, isVM, iu)
+		if err != nil {
+			if soap.IsSoapFault(err) {
+				fault := soap.ToSoapFault(err).VimFault()
+				if _, ok := fault.(types.InvalidArgument); ok {
+					continue
+				}
+			}
+			return nil, err
+		}
+		if ref != nil {
+			break
+		}
+	}
+
+	return ref, nil
+}
+
+func (flag *SearchFlag) search() (object.Reference, error) {
+	ctx := context.TODO()
+	var ref object.Reference
+	var err error
+
+	c, err := flag.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	dc, err := flag.Datacenter()
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	case flag.byDatastorePath != "":
+		ref, err = flag.searchByDatastorePath(c, dc)
+	case flag.byDNSName != "":
+		ref, err = flag.searchByDNSName(c, dc)
+	case flag.byInventoryPath != "":
+		ref, err = flag.searchByInventoryPath(c, dc)
+	case flag.byIP != "":
+		ref, err = flag.searchByIP(c, dc)
+	case flag.byUUID != "":
+		ref, err = flag.searchByUUID(c, dc)
+	default:
+		err = errors.New("no search flag specified")
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if ref == nil {
+		return nil, fmt.Errorf("no such %s", flag.entity)
+	}
+
+	// set the InventoryPath field
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+	ref, err = finder.ObjectReference(ctx, ref.Reference())
+	if err != nil {
+		return nil, err
+	}
+
+	return ref, nil
+}
+
+func (flag *SearchFlag) VirtualMachine() (*object.VirtualMachine, error) {
+	ref, err := flag.search()
+	if err != nil {
+		return nil, err
+	}
+
+	vm, ok := ref.(*object.VirtualMachine)
+	if !ok {
+		return nil, fmt.Errorf("expected VirtualMachine entity, got %s", ref.Reference().Type)
+	}
+
+	return vm, nil
+}
+
+func (flag *SearchFlag) VirtualMachines(args []string) ([]*object.VirtualMachine, error) {
+	ctx := context.TODO()
+	var out []*object.VirtualMachine
+
+	if flag.IsSet() {
+		vm, err := flag.VirtualMachine()
+		if err != nil {
+			return nil, err
+		}
+
+		out = append(out, vm)
+		return out, nil
+	}
+
+	// List virtual machines
+	if len(args) == 0 {
+		return nil, errors.New("no argument")
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	var nfe error
+
+	// List virtual machines for every argument
+	for _, arg := range args {
+		vms, err := finder.VirtualMachineList(ctx, arg)
+		if err != nil {
+			if _, ok := err.(*find.NotFoundError); ok {
+				// Let caller decide how to handle NotFoundError
+				nfe = err
+				continue
+			}
+			return nil, err
+		}
+
+		out = append(out, vms...)
+	}
+
+	return out, nfe
+}
+
+func (flag *SearchFlag) VirtualApp() (*object.VirtualApp, error) {
+	ref, err := flag.search()
+	if err != nil {
+		return nil, err
+	}
+
+	app, ok := ref.(*object.VirtualApp)
+	if !ok {
+		return nil, fmt.Errorf("expected VirtualApp entity, got %s", ref.Reference().Type)
+	}
+
+	return app, nil
+}
+
+func (flag *SearchFlag) VirtualApps(args []string) ([]*object.VirtualApp, error) {
+	ctx := context.TODO()
+	var out []*object.VirtualApp
+
+	if flag.IsSet() {
+		app, err := flag.VirtualApp()
+		if err != nil {
+			return nil, err
+		}
+
+		out = append(out, app)
+		return out, nil
+	}
+
+	// List virtual apps
+	if len(args) == 0 {
+		return nil, errors.New("no argument")
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	// List virtual apps for every argument
+	for _, arg := range args {
+		apps, err := finder.VirtualAppList(ctx, arg)
+		if err != nil {
+			return nil, err
+		}
+
+		out = append(out, apps...)
+	}
+
+	return out, nil
+}
+
+func (flag *SearchFlag) HostSystem() (*object.HostSystem, error) {
+	ref, err := flag.search()
+	if err != nil {
+		return nil, err
+	}
+
+	host, ok := ref.(*object.HostSystem)
+	if !ok {
+		return nil, fmt.Errorf("expected HostSystem entity, got %s", ref.Reference().Type)
+	}
+
+	return host, nil
+}
+
+func (flag *SearchFlag) HostSystems(args []string) ([]*object.HostSystem, error) {
+	ctx := context.TODO()
+	var out []*object.HostSystem
+
+	if flag.IsSet() {
+		host, err := flag.HostSystem()
+		if err != nil {
+			return nil, err
+		}
+
+		out = append(out, host)
+		return out, nil
+	}
+
+	// List host system
+	if len(args) == 0 {
+		return nil, errors.New("no argument")
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	// List host systems for every argument
+	for _, arg := range args {
+		vms, err := finder.HostSystemList(ctx, arg)
+		if err != nil {
+			return nil, err
+		}
+
+		out = append(out, vms...)
+	}
+
+	return out, nil
+}

vendor/github.com/vmware/govmomi/govc/flags/storage_pod.go

@@ -0,0 +1,78 @@
+package flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+)
+
+type StoragePodFlag struct {
+	common
+
+	*DatacenterFlag
+
+	Name string
+
+	sp *object.StoragePod
+}
+
+var storagePodFlagKey = flagKey("storagePod")
+
+func NewStoragePodFlag(ctx context.Context) (*StoragePodFlag, context.Context) {
+	if v := ctx.Value(storagePodFlagKey); v != nil {
+		return v.(*StoragePodFlag), ctx
+	}
+
+	v := &StoragePodFlag{}
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	ctx = context.WithValue(ctx, storagePodFlagKey, v)
+	return v, ctx
+}
+
+func (f *StoragePodFlag) Register(ctx context.Context, fs *flag.FlagSet) {
+	f.RegisterOnce(func() {
+		f.DatacenterFlag.Register(ctx, fs)
+
+		env := "GOVC_DATASTORE_CLUSTER"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Datastore cluster [%s]", env)
+		fs.StringVar(&f.Name, "datastore-cluster", value, usage)
+	})
+}
+
+func (f *StoragePodFlag) Process(ctx context.Context) error {
+	return f.DatacenterFlag.Process(ctx)
+}
+
+func (f *StoragePodFlag) Isset() bool {
+	return f.Name != ""
+}
+
+func (f *StoragePodFlag) StoragePod() (*object.StoragePod, error) {
+	ctx := context.TODO()
+	if f.sp != nil {
+		return f.sp, nil
+	}
+
+	finder, err := f.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	if f.Isset() {
+		f.sp, err = finder.DatastoreCluster(ctx, f.Name)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		f.sp, err = finder.DefaultDatastoreCluster(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return f.sp, nil
+}

vendor/github.com/vmware/govmomi/govc/flags/version.go

@@ -0,0 +1,63 @@
+/*
+Copyright (c) 2014 VMware, 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 flags
+
+import (
+	"strconv"
+	"strings"
+)
+
+const Version = "0.15.0"
+
+type version []int
+
+func ParseVersion(s string) (version, error) {
+	v := make(version, 0)
+	ps := strings.Split(s, ".")
+	for _, p := range ps {
+		i, err := strconv.Atoi(p)
+		if err != nil {
+			return nil, err
+		}
+
+		v = append(v, i)
+	}
+
+	return v, nil
+}
+
+func (v version) Lte(u version) bool {
+	lv := len(v)
+	lu := len(u)
+
+	for i := 0; i < lv; i++ {
+		// Everything up to here has been equal and v has more elements than u.
+		if i >= lu {
+			return false
+		}
+
+		// Move to next digit if equal.
+		if v[i] == u[i] {
+			continue
+		}
+
+		return v[i] < u[i]
+	}
+
+	// Equal.
+	return true
+}

vendor/github.com/vmware/govmomi/govc/flags/version_test.go

@@ -0,0 +1,63 @@
+/*
+Copyright (c) 2014 VMware, 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 flags
+
+import "testing"
+
+func TestParseVersion(t *testing.T) {
+	var v version
+	var err error
+
+	v, err = ParseVersion("5.5.5.5")
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(v) != 4 {
+		t.Errorf("Expected %d elements, got %d", 4, len(v))
+	}
+
+	for i := 0; i < len(v); i++ {
+		if v[i] != 5 {
+			t.Errorf("Expected %d, got %d", 5, v[i])
+		}
+	}
+}
+
+func TestLte(t *testing.T) {
+	v1, err := ParseVersion("5.5")
+	if err != nil {
+		panic(err)
+	}
+
+	v2, err := ParseVersion("5.6")
+	if err != nil {
+		panic(err)
+	}
+
+	if !v1.Lte(v1) {
+		t.Errorf("Expected 5.5 <= 5.5")
+	}
+
+	if !v1.Lte(v2) {
+		t.Errorf("Expected 5.5 <= 5.6")
+	}
+
+	if v2.Lte(v1) {
+		t.Errorf("Expected not 5.6 <= 5.5")
+	}
+}

vendor/github.com/vmware/govmomi/govc/flags/virtual_app.go

@@ -0,0 +1,106 @@
+/*
+Copyright (c) 2015 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+)
+
+type VirtualAppFlag struct {
+	common
+
+	*DatacenterFlag
+	*SearchFlag
+
+	name string
+	app  *object.VirtualApp
+}
+
+var virtualAppFlagKey = flagKey("virtualApp")
+
+func NewVirtualAppFlag(ctx context.Context) (*VirtualAppFlag, context.Context) {
+	if v := ctx.Value(virtualAppFlagKey); v != nil {
+		return v.(*VirtualAppFlag), ctx
+	}
+
+	v := &VirtualAppFlag{}
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	v.SearchFlag, ctx = NewSearchFlag(ctx, SearchVirtualApps)
+	ctx = context.WithValue(ctx, virtualAppFlagKey, v)
+	return v, ctx
+}
+
+func (flag *VirtualAppFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.DatacenterFlag.Register(ctx, f)
+		flag.SearchFlag.Register(ctx, f)
+
+		env := "GOVC_VAPP"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Virtual App [%s]", env)
+		f.StringVar(&flag.name, "vapp", value, usage)
+	})
+}
+
+func (flag *VirtualAppFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.SearchFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *VirtualAppFlag) VirtualApp() (*object.VirtualApp, error) {
+	ctx := context.TODO()
+
+	if flag.app != nil {
+		return flag.app, nil
+	}
+
+	// Use search flags if specified.
+	if flag.SearchFlag.IsSet() {
+		app, err := flag.SearchFlag.VirtualApp()
+		if err != nil {
+			return nil, err
+		}
+
+		flag.app = app
+		return flag.app, nil
+	}
+
+	// Never look for a default virtual app.
+	if flag.name == "" {
+		return nil, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	flag.app, err = finder.VirtualApp(ctx, flag.name)
+	return flag.app, err
+}

vendor/github.com/vmware/govmomi/govc/flags/virtual_machine.go

@@ -0,0 +1,112 @@
+/*
+Copyright (c) 2014-2015 VMware, 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 flags
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/object"
+)
+
+type VirtualMachineFlag struct {
+	common
+
+	*ClientFlag
+	*DatacenterFlag
+	*SearchFlag
+
+	name string
+	vm   *object.VirtualMachine
+}
+
+var virtualMachineFlagKey = flagKey("virtualMachine")
+
+func NewVirtualMachineFlag(ctx context.Context) (*VirtualMachineFlag, context.Context) {
+	if v := ctx.Value(virtualMachineFlagKey); v != nil {
+		return v.(*VirtualMachineFlag), ctx
+	}
+
+	v := &VirtualMachineFlag{}
+	v.ClientFlag, ctx = NewClientFlag(ctx)
+	v.DatacenterFlag, ctx = NewDatacenterFlag(ctx)
+	v.SearchFlag, ctx = NewSearchFlag(ctx, SearchVirtualMachines)
+	ctx = context.WithValue(ctx, virtualMachineFlagKey, v)
+	return v, ctx
+}
+
+func (flag *VirtualMachineFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.RegisterOnce(func() {
+		flag.ClientFlag.Register(ctx, f)
+		flag.DatacenterFlag.Register(ctx, f)
+		flag.SearchFlag.Register(ctx, f)
+
+		env := "GOVC_VM"
+		value := os.Getenv(env)
+		usage := fmt.Sprintf("Virtual machine [%s]", env)
+		f.StringVar(&flag.name, "vm", value, usage)
+	})
+}
+
+func (flag *VirtualMachineFlag) Process(ctx context.Context) error {
+	return flag.ProcessOnce(func() error {
+		if err := flag.ClientFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.DatacenterFlag.Process(ctx); err != nil {
+			return err
+		}
+		if err := flag.SearchFlag.Process(ctx); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (flag *VirtualMachineFlag) VirtualMachine() (*object.VirtualMachine, error) {
+	ctx := context.TODO()
+
+	if flag.vm != nil {
+		return flag.vm, nil
+	}
+
+	// Use search flags if specified.
+	if flag.SearchFlag.IsSet() {
+		vm, err := flag.SearchFlag.VirtualMachine()
+		if err != nil {
+			return nil, err
+		}
+
+		flag.vm = vm
+		return flag.vm, nil
+	}
+
+	// Never look for a default virtual machine.
+	if flag.name == "" {
+		return nil, nil
+	}
+
+	finder, err := flag.Finder()
+	if err != nil {
+		return nil, err
+	}
+
+	flag.vm, err = finder.VirtualMachine(ctx, flag.name)
+	return flag.vm, err
+}