add vendoring with go dep

vendor/github.com/vmware/govmomi/govc/host/esxcli/command.go

@@ -0,0 +1,149 @@
+/*
+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 esxcli
+
+import (
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type Command struct {
+	name []string
+	args []string
+}
+
+type CommandInfoItem struct {
+	Name        string `xml:"name"`
+	DisplayName string `xml:"displayName"`
+	Help        string `xml:"help"`
+}
+
+type CommandInfoParam struct {
+	CommandInfoItem
+	Aliases []string `xml:"aliases"`
+	Flag    bool     `xml:"flag"`
+}
+
+type CommandInfoHint struct {
+	Key   string `xml:"key"`
+	Value string `xml:"value"`
+}
+
+type CommandInfoHints []CommandInfoHint
+
+type CommandInfoMethod struct {
+	CommandInfoItem
+	Param []CommandInfoParam `xml:"param"`
+	Hints CommandInfoHints   `xml:"hints"`
+}
+
+type CommandInfo struct {
+	CommandInfoItem
+	Method []*CommandInfoMethod `xml:"method"`
+}
+
+func NewCommand(args []string) *Command {
+	c := &Command{}
+
+	for i, arg := range args {
+		if strings.HasPrefix(arg, "-") {
+			c.args = args[i:]
+			break
+		} else {
+			c.name = append(c.name, arg)
+		}
+	}
+
+	return c
+}
+
+func (c *Command) Namespace() string {
+	return strings.Join(c.name[:len(c.name)-1], ".")
+}
+
+func (c *Command) Name() string {
+	return c.name[len(c.name)-1]
+}
+
+func (c *Command) Method() string {
+	return "vim.EsxCLI." + strings.Join(c.name, ".")
+}
+
+func (c *Command) Moid() string {
+	return "ha-cli-handler-" + strings.Join(c.name[:len(c.name)-1], "-")
+}
+
+// Parse generates a flag.FlagSet based on the given []CommandInfoParam and
+// returns arguments for use with methods.ExecuteSoap
+func (c *Command) Parse(params []CommandInfoParam) ([]types.ReflectManagedMethodExecuterSoapArgument, error) {
+	flags := flag.NewFlagSet(strings.Join(c.name, " "), flag.ExitOnError)
+	vals := make([]string, len(params))
+
+	for i, p := range params {
+		v := &vals[i]
+		for _, a := range p.Aliases {
+			a = strings.TrimPrefix(a[1:], "-")
+			flags.StringVar(v, a, "", p.Help)
+		}
+	}
+
+	err := flags.Parse(c.args)
+	if err != nil {
+		return nil, err
+	}
+
+	args := []types.ReflectManagedMethodExecuterSoapArgument{}
+
+	for i, p := range params {
+		if vals[i] == "" {
+			continue
+		}
+		args = append(args, c.Argument(p.Name, vals[i]))
+	}
+
+	return args, nil
+}
+
+func (c *Command) Argument(name string, val string) types.ReflectManagedMethodExecuterSoapArgument {
+	return types.ReflectManagedMethodExecuterSoapArgument{
+		Name: name,
+		Val:  fmt.Sprintf("<%s>%s</%s>", name, val, name),
+	}
+}
+
+func (h CommandInfoHints) Formatter() string {
+	for _, hint := range h {
+		if hint.Key == "formatter" {
+			return hint.Value
+		}
+	}
+
+	return "simple"
+}
+
+func (h CommandInfoHints) Fields() []string {
+	for _, hint := range h {
+		if strings.HasPrefix(hint.Key, "fields:") {
+			return strings.Split(hint.Value, ",")
+		}
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/command_test.go

@@ -0,0 +1,124 @@
+/*
+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 esxcli
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+func TestSystemSettingsAdvancedSetCommand(t *testing.T) {
+	c := NewCommand([]string{"system", "settings", "advanced", "set", "-o", "/Net/GuestIPHack", "-i", "1"})
+
+	tests := []struct {
+		f      func() string
+		expect string
+	}{
+		{c.Name, "set"},
+		{c.Namespace, "system.settings.advanced"},
+		{c.Method, "vim.EsxCLI.system.settings.advanced.set"},
+		{c.Moid, "ha-cli-handler-system-settings-advanced"},
+	}
+
+	for _, test := range tests {
+		actual := test.f()
+		if actual != test.expect {
+			t.Errorf("%s != %s", actual, test.expect)
+		}
+	}
+
+	params := []CommandInfoParam{
+		{
+			CommandInfoItem: CommandInfoItem{Name: "default", DisplayName: "default", Help: "Reset the option to its default value."},
+			Aliases:         []string{"-d", "--default"},
+			Flag:            true,
+		},
+		{
+			CommandInfoItem: CommandInfoItem{Name: "intvalue", DisplayName: "int-value", Help: "If the option is an integer value use this option."},
+			Aliases:         []string{"-i", "--int-value"},
+			Flag:            false,
+		},
+		{
+			CommandInfoItem: CommandInfoItem{Name: "option", DisplayName: "option", Help: "The name of the option to set the value of. Example: \"/Misc/HostName\""},
+			Aliases:         []string{"-o", "--option"},
+			Flag:            false,
+		},
+		{
+			CommandInfoItem: CommandInfoItem{Name: "stringvalue", DisplayName: "string-value", Help: "If the option is a string use this option."},
+			Aliases:         []string{"-s", "--string-value"},
+			Flag:            false,
+		},
+	}
+
+	args, err := c.Parse(params)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expect := []types.ReflectManagedMethodExecuterSoapArgument{
+		{
+			DynamicData: types.DynamicData{},
+			Name:        "intvalue",
+			Val:         "<intvalue>1</intvalue>",
+		},
+		{
+			DynamicData: types.DynamicData{},
+			Name:        "option",
+			Val:         "<option>/Net/GuestIPHack</option>",
+		},
+	}
+
+	if !reflect.DeepEqual(args, expect) {
+		t.Errorf("%s != %s", args, expect)
+	}
+}
+
+func TestNetworkVmListCommand(t *testing.T) {
+	c := NewCommand([]string{"network", "vm", "list"})
+
+	tests := []struct {
+		f      func() string
+		expect string
+	}{
+		{c.Name, "list"},
+		{c.Namespace, "network.vm"},
+		{c.Method, "vim.EsxCLI.network.vm.list"},
+		{c.Moid, "ha-cli-handler-network-vm"},
+	}
+
+	for _, test := range tests {
+		actual := test.f()
+		if actual != test.expect {
+			t.Errorf("%s != %s", actual, test.expect)
+		}
+	}
+
+	var params []CommandInfoParam
+
+	args, err := c.Parse(params)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expect := []types.ReflectManagedMethodExecuterSoapArgument{}
+
+	if !reflect.DeepEqual(args, expect) {
+		t.Errorf("%s != %s", args, expect)
+	}
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/esxcli.go

@@ -0,0 +1,172 @@
+/*
+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 esxcli
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+)
+
+type esxcli struct {
+	*flags.HostSystemFlag
+
+	hints bool
+}
+
+func init() {
+	cli.Register("host.esxcli", &esxcli{})
+}
+
+func (cmd *esxcli) Usage() string {
+	return "COMMAND [ARG]..."
+}
+
+func (cmd *esxcli) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
+	cmd.HostSystemFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.hints, "hints", true, "Use command info hints when formatting output")
+}
+
+func (cmd *esxcli) Description() string {
+	return `Invoke esxcli command on HOST.
+
+Output is rendered in table form when possible, unless disabled with '-hints=false'.
+
+Examples:
+  govc host.esxcli network ip connection list
+  govc host.esxcli system settings advanced set -o /Net/GuestIPHack -i 1
+  govc host.esxcli network firewall ruleset set -r remoteSerialPort -e true
+  govc host.esxcli network firewall set -e false`
+}
+
+func (cmd *esxcli) Process(ctx context.Context) error {
+	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *esxcli) Run(ctx context.Context, f *flag.FlagSet) error {
+	c, err := cmd.Client()
+	if err != nil {
+		return nil
+	}
+
+	host, err := cmd.HostSystem()
+	if err != nil {
+		return err
+	}
+
+	e, err := NewExecutor(c, host)
+	if err != nil {
+		return err
+	}
+
+	res, err := e.Run(f.Args())
+	if err != nil {
+		return err
+	}
+
+	if len(res.Values) == 0 {
+		return nil
+	}
+
+	return cmd.WriteResult(&result{res, cmd})
+}
+
+type result struct {
+	*Response
+	cmd *esxcli
+}
+
+func (r *result) Write(w io.Writer) error {
+	var formatType string
+	if r.cmd.hints {
+		formatType = r.Info.Hints.Formatter()
+	}
+
+	switch formatType {
+	case "table":
+		r.cmd.formatTable(w, r.Response)
+	default:
+		r.cmd.formatSimple(w, r.Response)
+	}
+
+	return nil
+}
+
+func (cmd *esxcli) formatSimple(w io.Writer, res *Response) {
+	var keys []string
+	for key := range res.Values[0] {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
+
+	for i, rv := range res.Values {
+		if i > 0 {
+			fmt.Fprintln(tw)
+			_ = tw.Flush()
+		}
+		for _, key := range keys {
+			fmt.Fprintf(tw, "%s:\t%s\n", key, strings.Join(rv[key], ", "))
+		}
+	}
+
+	_ = tw.Flush()
+}
+
+func (cmd *esxcli) formatTable(w io.Writer, res *Response) {
+	fields := res.Info.Hints.Fields()
+
+	tw := tabwriter.NewWriter(w, len(fields), 0, 2, ' ', 0)
+
+	var hr []string
+	for _, name := range fields {
+		hr = append(hr, strings.Repeat("-", len(name)))
+	}
+
+	fmt.Fprintln(tw, strings.Join(fields, "\t"))
+	fmt.Fprintln(tw, strings.Join(hr, "\t"))
+
+	for _, vals := range res.Values {
+		var row []string
+
+		for _, name := range fields {
+			key := strings.Replace(name, " ", "", -1)
+			if val, ok := vals[key]; ok {
+				row = append(row, strings.Join(val, ", "))
+			} else {
+				row = append(row, "")
+			}
+		}
+
+		fmt.Fprintln(tw, strings.Join(row, "\t"))
+	}
+
+	_ = tw.Flush()
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/executor.go

@@ -0,0 +1,168 @@
+/*
+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 esxcli
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+type Executor struct {
+	c    *vim25.Client
+	host *object.HostSystem
+	mme  *types.ReflectManagedMethodExecuter
+	dtm  *types.InternalDynamicTypeManager
+	info map[string]*CommandInfo
+}
+
+func NewExecutor(c *vim25.Client, host *object.HostSystem) (*Executor, error) {
+	ctx := context.TODO()
+	e := &Executor{
+		c:    c,
+		host: host,
+		info: make(map[string]*CommandInfo),
+	}
+
+	{
+		req := types.RetrieveManagedMethodExecuter{
+			This: host.Reference(),
+		}
+
+		res, err := methods.RetrieveManagedMethodExecuter(ctx, c, &req)
+		if err != nil {
+			return nil, err
+		}
+
+		e.mme = res.Returnval
+	}
+
+	{
+		req := types.RetrieveDynamicTypeManager{
+			This: host.Reference(),
+		}
+
+		res, err := methods.RetrieveDynamicTypeManager(ctx, c, &req)
+		if err != nil {
+			return nil, err
+		}
+
+		e.dtm = res.Returnval
+	}
+
+	return e, nil
+}
+
+func (e *Executor) CommandInfo(c *Command) (*CommandInfoMethod, error) {
+	ns := c.Namespace()
+	var info *CommandInfo
+	var ok bool
+
+	if info, ok = e.info[ns]; !ok {
+		req := types.ExecuteSoap{
+			Moid:   "ha-dynamic-type-manager-local-cli-cliinfo",
+			Method: "vim.CLIInfo.FetchCLIInfo",
+			Argument: []types.ReflectManagedMethodExecuterSoapArgument{
+				c.Argument("typeName", "vim.EsxCLI."+ns),
+			},
+		}
+
+		info = new(CommandInfo)
+		if err := e.Execute(&req, info); err != nil {
+			return nil, err
+		}
+
+		e.info[ns] = info
+	}
+
+	name := c.Name()
+	for _, method := range info.Method {
+		if method.Name == name {
+			return method, nil
+		}
+	}
+
+	return nil, fmt.Errorf("method '%s' not found in name space '%s'", name, c.Namespace())
+}
+
+func (e *Executor) NewRequest(args []string) (*types.ExecuteSoap, *CommandInfoMethod, error) {
+	c := NewCommand(args)
+
+	info, err := e.CommandInfo(c)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sargs, err := c.Parse(info.Param)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sreq := types.ExecuteSoap{
+		Moid:     c.Moid(),
+		Method:   c.Method(),
+		Argument: sargs,
+	}
+
+	return &sreq, info, nil
+}
+
+func (e *Executor) Execute(req *types.ExecuteSoap, res interface{}) error {
+	ctx := context.TODO()
+	req.This = e.mme.ManagedObjectReference
+	req.Version = "urn:vim25/5.0"
+
+	x, err := methods.ExecuteSoap(ctx, e.c, req)
+	if err != nil {
+		return err
+	}
+
+	if x.Returnval != nil {
+		if x.Returnval.Fault != nil {
+			return errors.New(x.Returnval.Fault.FaultMsg)
+		}
+
+		if err := xml.Unmarshal([]byte(x.Returnval.Response), res); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (e *Executor) Run(args []string) (*Response, error) {
+	req, info, err := e.NewRequest(args)
+	if err != nil {
+		return nil, err
+	}
+
+	res := &Response{
+		Info: info,
+	}
+
+	if err := e.Execute(req, res); err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/firewall_info.go

@@ -0,0 +1,48 @@
+/*
+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 esxcli
+
+import "github.com/vmware/govmomi/object"
+
+type FirewallInfo struct {
+	Loaded        bool
+	Enabled       bool
+	DefaultAction string
+}
+
+// GetFirewallInfo via 'esxcli network firewall get'
+// The HostFirewallSystem type does not expose this data.
+// This helper can be useful in particular to determine if the firewall is enabled or disabled.
+func GetFirewallInfo(s *object.HostSystem) (*FirewallInfo, error) {
+	x, err := NewExecutor(s.Client(), s)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := x.Run([]string{"network", "firewall", "get"})
+	if err != nil {
+		return nil, err
+	}
+
+	info := &FirewallInfo{
+		Loaded:        res.Values[0]["Loaded"][0] == "true",
+		Enabled:       res.Values[0]["Enabled"][0] == "true",
+		DefaultAction: res.Values[0]["DefaultAction"][0],
+	}
+
+	return info, nil
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/fixtures/network_vm_list.xml

@@ -0,0 +1,15 @@
+<obj xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:vim25" versionId="5.0" xsi:type="ArrayOfDataObject">
+ <DataObject xsi:type="VimEsxCLInetworkvmlistVM">
+  <Name>foo</Name>
+  <Networks>VM Network</Networks>
+  <Networks>dougm</Networks>
+  <NumPorts>2</NumPorts>
+  <WorldID>98842</WorldID>
+ </DataObject>
+ <DataObject xsi:type="VimEsxCLInetworkvmlistVM">
+  <Name>bar</Name>
+  <Networks>VM Network</Networks>
+  <NumPorts>1</NumPorts>
+  <WorldID>236235</WorldID>
+ </DataObject>
+</obj>

vendor/github.com/vmware/govmomi/govc/host/esxcli/fixtures/network_vm_port_list.xml

@@ -0,0 +1,12 @@
+<obj xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:vim25" versionId="5.0" xsi:type="ArrayOfDataObject">
+ <DataObject xsi:type="VimEsxCLInetworkvmportlistPort">
+  <DVPortID></DVPortID>
+  <IPAddress>192.168.247.149</IPAddress>
+  <MACAddress>00:0c:29:12:b2:cf</MACAddress>
+  <PortID>33554438</PortID>
+  <Portgroup>VM Network</Portgroup>
+  <TeamUplink>vmnic0</TeamUplink>
+  <UplinkPortID>33554434</UplinkPortID>
+  <vSwitch>vSwitch0</vSwitch>
+ </DataObject>
+</obj>

vendor/github.com/vmware/govmomi/govc/host/esxcli/fixtures/system_hostname_get.xml

@@ -0,0 +1,5 @@
+<obj xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="urn:vim25" versionId="5.0" xsi:type="VimEsxCLIsystemhostnamegetFullyQualifiedHostName">
+ <DomainName>localdomain</DomainName>
+ <FullyQualifiedDomainName>esxbox.localdomain</FullyQualifiedDomainName>
+ <HostName>esxbox</HostName>
+</obj>

vendor/github.com/vmware/govmomi/govc/host/esxcli/guest_info.go

@@ -0,0 +1,120 @@
+/*
+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 esxcli
+
+import (
+	"context"
+	"strings"
+
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type hostInfo struct {
+	*Executor
+	wids map[string]string
+}
+
+type GuestInfo struct {
+	c     *vim25.Client
+	hosts map[string]*hostInfo
+}
+
+func NewGuestInfo(c *vim25.Client) *GuestInfo {
+	return &GuestInfo{
+		c:     c,
+		hosts: make(map[string]*hostInfo),
+	}
+}
+
+func (g *GuestInfo) hostInfo(ref *types.ManagedObjectReference) (*hostInfo, error) {
+	// cache exectuor and uuid -> worldid map
+	if h, ok := g.hosts[ref.Value]; ok {
+		return h, nil
+	}
+
+	host := object.NewHostSystem(g.c, *ref)
+
+	e, err := NewExecutor(g.c, host)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := e.Run([]string{"vm", "process", "list"})
+	if err != nil {
+		return nil, err
+	}
+
+	ids := make(map[string]string, len(res.Values))
+
+	for _, process := range res.Values {
+		// Normalize uuid, esxcli and mo.VirtualMachine have different formats
+		uuid := strings.Replace(process["UUID"][0], " ", "", -1)
+		uuid = strings.Replace(uuid, "-", "", -1)
+
+		ids[uuid] = process["WorldID"][0]
+	}
+
+	h := &hostInfo{e, ids}
+	g.hosts[ref.Value] = h
+
+	return h, nil
+}
+
+// IpAddress attempts to find the guest IP address using esxcli.
+// ESX hosts must be configured with the /Net/GuestIPHack enabled.
+// For example:
+// $ govc host.esxcli -- system settings advanced set -o /Net/GuestIPHack -i 1
+func (g *GuestInfo) IpAddress(vm *object.VirtualMachine) (string, error) {
+	ctx := context.TODO()
+	const any = "0.0.0.0"
+	var mvm mo.VirtualMachine
+
+	pc := property.DefaultCollector(g.c)
+	err := pc.RetrieveOne(ctx, vm.Reference(), []string{"runtime.host", "config.uuid"}, &mvm)
+	if err != nil {
+		return "", err
+	}
+
+	h, err := g.hostInfo(mvm.Runtime.Host)
+	if err != nil {
+		return "", err
+	}
+
+	// Normalize uuid, esxcli and mo.VirtualMachine have different formats
+	uuid := strings.Replace(mvm.Config.Uuid, "-", "", -1)
+
+	if wid, ok := h.wids[uuid]; ok {
+		res, err := h.Run([]string{"network", "vm", "port", "list", "--world-id", wid})
+		if err != nil {
+			return "", err
+		}
+
+		for _, val := range res.Values {
+			if ip, ok := val["IPAddress"]; ok {
+				if ip[0] != any {
+					return ip[0], nil
+				}
+			}
+		}
+	}
+
+	return any, nil
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/response.go

@@ -0,0 +1,97 @@
+/*
+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 esxcli
+
+import (
+	"io"
+
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+type Values map[string][]string
+
+type Response struct {
+	Info   *CommandInfoMethod
+	Values []Values
+}
+
+func (v Values) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	for {
+		t, err := d.Token()
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+
+		if s, ok := t.(xml.StartElement); ok {
+			t, err = d.Token()
+			if err != nil {
+				return err
+			}
+
+			key := s.Name.Local
+			var val string
+			if c, ok := t.(xml.CharData); ok {
+				val = string(c)
+			}
+			v[key] = append(v[key], val)
+		}
+	}
+}
+
+func (r *Response) Type(start xml.StartElement) string {
+	for _, a := range start.Attr {
+		if a.Name.Local == "type" {
+			return a.Value
+		}
+	}
+	return ""
+}
+
+func (r *Response) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	stype := r.Type(start)
+
+	if stype != "ArrayOfDataObject" {
+		v := Values{}
+		if err := d.DecodeElement(&v, &start); err != nil {
+			return err
+		}
+		r.Values = append(r.Values, v)
+		return nil
+	}
+
+	for {
+		t, err := d.Token()
+		if err != nil {
+			if err == io.EOF {
+				return nil
+			}
+			return err
+		}
+
+		if s, ok := t.(xml.StartElement); ok {
+			if s.Name.Local == "DataObject" {
+				v := Values{}
+				if err := d.DecodeElement(&v, &s); err != nil {
+					return err
+				}
+				r.Values = append(r.Values, v)
+			}
+		}
+	}
+}

vendor/github.com/vmware/govmomi/govc/host/esxcli/response_test.go

@@ -0,0 +1,105 @@
+/*
+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 esxcli
+
+import (
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/types"
+	"github.com/vmware/govmomi/vim25/xml"
+)
+
+func load(name string) *Response {
+	f, err := os.Open(name)
+	if err != nil {
+		panic(err)
+	}
+
+	defer f.Close()
+
+	var b Response
+
+	dec := xml.NewDecoder(f)
+	dec.TypeFunc = types.TypeFunc()
+	if err := dec.Decode(&b); err != nil {
+		panic(err)
+	}
+
+	return &b
+}
+
+func TestSystemHostnameGetResponse(t *testing.T) {
+	res := load("fixtures/system_hostname_get.xml")
+
+	expect := []Values{
+		{
+			"DomainName":               {"localdomain"},
+			"FullyQualifiedDomainName": {"esxbox.localdomain"},
+			"HostName":                 {"esxbox"},
+		},
+	}
+
+	if !reflect.DeepEqual(res.Values, expect) {
+		t.Errorf("%s != %s", res.Values, expect)
+	}
+}
+
+func TestNetworkVmList(t *testing.T) {
+	res := load("fixtures/network_vm_list.xml")
+
+	expect := []Values{
+		{
+			"Name":     {"foo"},
+			"Networks": {"VM Network", "dougm"},
+			"NumPorts": {"2"},
+			"WorldID":  {"98842"},
+		},
+		{
+			"Name":     {"bar"},
+			"Networks": {"VM Network"},
+			"NumPorts": {"1"},
+			"WorldID":  {"236235"},
+		},
+	}
+
+	if !reflect.DeepEqual(res.Values, expect) {
+		t.Errorf("%s != %s", res.Values, expect)
+	}
+}
+
+func TestNetworkVmPortList(t *testing.T) {
+	r := load("fixtures/network_vm_port_list.xml")
+
+	expect := []Values{
+		{
+			"IPAddress":    {"192.168.247.149"},
+			"MACAddress":   {"00:0c:29:12:b2:cf"},
+			"PortID":       {"33554438"},
+			"Portgroup":    {"VM Network"},
+			"TeamUplink":   {"vmnic0"},
+			"UplinkPortID": {"33554434"},
+			"vSwitch":      {"vSwitch0"},
+			"DVPortID":     {""},
+		},
+	}
+
+	if !reflect.DeepEqual(r.Values, expect) {
+		t.Errorf("%s != %s", r.Values, expect)
+	}
+}