VMware vSphere Integrated Containers provider (#206)

* Add Virtual Kubelet provider for VIC

Initial virtual kubelet provider for VMware VIC.  This provider currently
handles creating and starting of a pod VM via the VIC portlayer and persona
server.  Image store handling via the VIC persona server.  This provider
currently requires the feature/wolfpack branch of VIC.

* Added pod stop and delete.  Also added node capacity.

Added the ability to stop and delete pod VMs via VIC.  Also retrieve
node capacity information from the VCH.

* Cleanup and readme file

Some file clean up and added a Readme.md markdown file for the VIC
provider.

* Cleaned up errors, added function comments, moved operation code

1. Cleaned up error handling.  Set standard for creating errors.
2. Added method prototype comments for all interface functions.
3. Moved PodCreator, PodStarter, PodStopper, and PodDeleter to a new folder.

* Add mocking code and unit tests for podcache, podcreator, and podstarter

Used the unit test framework used in VIC to handle assertions in the provider's
unit test.  Mocking code generated using OSS project mockery, which is compatible
with the testify assertion framework.

* Vendored packages for the VIC provider

Requires feature/wolfpack branch of VIC and a few specific commit sha of
projects used within VIC.

* Implementation of POD Stopper and Deleter unit tests (#4)

* Updated files for initial PR

vendor/github.com/vmware/govmomi/object/authorization_manager.go

@@ -0,0 +1,174 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type AuthorizationManager struct {
+	Common
+}
+
+func NewAuthorizationManager(c *vim25.Client) *AuthorizationManager {
+	m := AuthorizationManager{
+		Common: NewCommon(c, *c.ServiceContent.AuthorizationManager),
+	}
+
+	return &m
+}
+
+type AuthorizationRoleList []types.AuthorizationRole
+
+func (l AuthorizationRoleList) ById(id int32) *types.AuthorizationRole {
+	for _, role := range l {
+		if role.RoleId == id {
+			return &role
+		}
+	}
+
+	return nil
+}
+
+func (l AuthorizationRoleList) ByName(name string) *types.AuthorizationRole {
+	for _, role := range l {
+		if role.Name == name {
+			return &role
+		}
+	}
+
+	return nil
+}
+
+func (m AuthorizationManager) RoleList(ctx context.Context) (AuthorizationRoleList, error) {
+	var am mo.AuthorizationManager
+
+	err := m.Properties(ctx, m.Reference(), []string{"roleList"}, &am)
+	if err != nil {
+		return nil, err
+	}
+
+	return AuthorizationRoleList(am.RoleList), nil
+}
+
+func (m AuthorizationManager) RetrieveEntityPermissions(ctx context.Context, entity types.ManagedObjectReference, inherited bool) ([]types.Permission, error) {
+	req := types.RetrieveEntityPermissions{
+		This:      m.Reference(),
+		Entity:    entity,
+		Inherited: inherited,
+	}
+
+	res, err := methods.RetrieveEntityPermissions(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (m AuthorizationManager) RemoveEntityPermission(ctx context.Context, entity types.ManagedObjectReference, user string, isGroup bool) error {
+	req := types.RemoveEntityPermission{
+		This:    m.Reference(),
+		Entity:  entity,
+		User:    user,
+		IsGroup: isGroup,
+	}
+
+	_, err := methods.RemoveEntityPermission(ctx, m.Client(), &req)
+	return err
+}
+
+func (m AuthorizationManager) SetEntityPermissions(ctx context.Context, entity types.ManagedObjectReference, permission []types.Permission) error {
+	req := types.SetEntityPermissions{
+		This:       m.Reference(),
+		Entity:     entity,
+		Permission: permission,
+	}
+
+	_, err := methods.SetEntityPermissions(ctx, m.Client(), &req)
+	return err
+}
+
+func (m AuthorizationManager) RetrieveRolePermissions(ctx context.Context, id int32) ([]types.Permission, error) {
+	req := types.RetrieveRolePermissions{
+		This:   m.Reference(),
+		RoleId: id,
+	}
+
+	res, err := methods.RetrieveRolePermissions(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (m AuthorizationManager) RetrieveAllPermissions(ctx context.Context) ([]types.Permission, error) {
+	req := types.RetrieveAllPermissions{
+		This: m.Reference(),
+	}
+
+	res, err := methods.RetrieveAllPermissions(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (m AuthorizationManager) AddRole(ctx context.Context, name string, ids []string) (int32, error) {
+	req := types.AddAuthorizationRole{
+		This:    m.Reference(),
+		Name:    name,
+		PrivIds: ids,
+	}
+
+	res, err := methods.AddAuthorizationRole(ctx, m.Client(), &req)
+	if err != nil {
+		return -1, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (m AuthorizationManager) RemoveRole(ctx context.Context, id int32, failIfUsed bool) error {
+	req := types.RemoveAuthorizationRole{
+		This:       m.Reference(),
+		RoleId:     id,
+		FailIfUsed: failIfUsed,
+	}
+
+	_, err := methods.RemoveAuthorizationRole(ctx, m.Client(), &req)
+	return err
+}
+
+func (m AuthorizationManager) UpdateRole(ctx context.Context, id int32, name string, ids []string) error {
+	req := types.UpdateAuthorizationRole{
+		This:    m.Reference(),
+		RoleId:  id,
+		NewName: name,
+		PrivIds: ids,
+	}
+
+	_, err := methods.UpdateAuthorizationRole(ctx, m.Client(), &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/authorization_manager_internal.go

@@ -0,0 +1,86 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DisabledMethodRequest struct {
+	Method string `xml:"method"`
+	Reason string `xml:"reasonId"`
+}
+
+type disableMethodsRequest struct {
+	This   types.ManagedObjectReference   `xml:"_this"`
+	Entity []types.ManagedObjectReference `xml:"entity"`
+	Method []DisabledMethodRequest        `xml:"method"`
+	Source string                         `xml:"sourceId"`
+	Scope  bool                           `xml:"sessionScope,omitempty"`
+}
+
+type disableMethodsBody struct {
+	Req *disableMethodsRequest `xml:"urn:internalvim25 DisableMethods,omitempty"`
+	Res interface{}            `xml:"urn:vim25 DisableMethodsResponse,omitempty"`
+	Err *soap.Fault            `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
+}
+
+func (b *disableMethodsBody) Fault() *soap.Fault { return b.Err }
+
+func (m AuthorizationManager) DisableMethods(ctx context.Context, entity []types.ManagedObjectReference, method []DisabledMethodRequest, source string) error {
+	var reqBody, resBody disableMethodsBody
+
+	reqBody.Req = &disableMethodsRequest{
+		This:   m.Reference(),
+		Entity: entity,
+		Method: method,
+		Source: source,
+	}
+
+	return m.Client().RoundTrip(ctx, &reqBody, &resBody)
+}
+
+type enableMethodsRequest struct {
+	This   types.ManagedObjectReference   `xml:"_this"`
+	Entity []types.ManagedObjectReference `xml:"entity"`
+	Method []string                       `xml:"method"`
+	Source string                         `xml:"sourceId"`
+}
+
+type enableMethodsBody struct {
+	Req *enableMethodsRequest `xml:"urn:internalvim25 EnableMethods,omitempty"`
+	Res interface{}           `xml:"urn:vim25 EnableMethodsResponse,omitempty"`
+	Err *soap.Fault           `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
+}
+
+func (b *enableMethodsBody) Fault() *soap.Fault { return b.Err }
+
+func (m AuthorizationManager) EnableMethods(ctx context.Context, entity []types.ManagedObjectReference, method []string, source string) error {
+	var reqBody, resBody enableMethodsBody
+
+	reqBody.Req = &enableMethodsRequest{
+		This:   m.Reference(),
+		Entity: entity,
+		Method: method,
+		Source: source,
+	}
+
+	return m.Client().RoundTrip(ctx, &reqBody, &resBody)
+}

vendor/github.com/vmware/govmomi/object/cluster_compute_resource.go

@@ -0,0 +1,70 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ClusterComputeResource struct {
+	ComputeResource
+}
+
+func NewClusterComputeResource(c *vim25.Client, ref types.ManagedObjectReference) *ClusterComputeResource {
+	return &ClusterComputeResource{
+		ComputeResource: *NewComputeResource(c, ref),
+	}
+}
+
+func (c ClusterComputeResource) Configuration(ctx context.Context) (*types.ClusterConfigInfoEx, error) {
+	var obj mo.ClusterComputeResource
+
+	err := c.Properties(ctx, c.Reference(), []string{"configurationEx"}, &obj)
+	if err != nil {
+		return nil, err
+	}
+
+	return obj.ConfigurationEx.(*types.ClusterConfigInfoEx), nil
+}
+
+func (c ClusterComputeResource) AddHost(ctx context.Context, spec types.HostConnectSpec, asConnected bool, license *string, resourcePool *types.ManagedObjectReference) (*Task, error) {
+	req := types.AddHost_Task{
+		This:        c.Reference(),
+		Spec:        spec,
+		AsConnected: asConnected,
+	}
+
+	if license != nil {
+		req.License = *license
+	}
+
+	if resourcePool != nil {
+		req.ResourcePool = resourcePool
+	}
+
+	res, err := methods.AddHost_Task(ctx, c.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(c.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/cluster_compute_resource_test.go

@@ -0,0 +1,20 @@
+/*
+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 object
+
+// ComputeResource should implement the Reference interface.
+var _ Reference = ClusterComputeResource{}

vendor/github.com/vmware/govmomi/object/common.go

@@ -0,0 +1,132 @@
+/*
+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 object
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"path"
+
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+var (
+	ErrNotSupported = errors.New("product/version specific feature not supported by target")
+)
+
+// Common contains the fields and functions common to all objects.
+type Common struct {
+	InventoryPath string
+
+	c *vim25.Client
+	r types.ManagedObjectReference
+}
+
+func (c Common) String() string {
+	ref := fmt.Sprintf("%v", c.Reference())
+
+	if c.InventoryPath == "" {
+		return ref
+	}
+
+	return fmt.Sprintf("%s @ %s", ref, c.InventoryPath)
+}
+
+func NewCommon(c *vim25.Client, r types.ManagedObjectReference) Common {
+	return Common{c: c, r: r}
+}
+
+func (c Common) Reference() types.ManagedObjectReference {
+	return c.r
+}
+
+func (c Common) Client() *vim25.Client {
+	return c.c
+}
+
+// Name returns the base name of the InventoryPath field
+func (c Common) Name() string {
+	if c.InventoryPath == "" {
+		return ""
+	}
+	return path.Base(c.InventoryPath)
+}
+
+func (c *Common) SetInventoryPath(p string) {
+	c.InventoryPath = p
+}
+
+// ObjectName returns the base name of the InventoryPath field if set,
+// otherwise fetches the mo.ManagedEntity.Name field via the property collector.
+func (c Common) ObjectName(ctx context.Context) (string, error) {
+	var o mo.ManagedEntity
+
+	err := c.Properties(ctx, c.Reference(), []string{"name"}, &o)
+	if err != nil {
+		return "", err
+	}
+
+	if o.Name != "" {
+		return o.Name, nil
+	}
+
+	// Network has its own "name" field...
+	var n mo.Network
+
+	err = c.Properties(ctx, c.Reference(), []string{"name"}, &n)
+	if err != nil {
+		return "", err
+	}
+
+	return n.Name, nil
+}
+
+func (c Common) Properties(ctx context.Context, r types.ManagedObjectReference, ps []string, dst interface{}) error {
+	return property.DefaultCollector(c.c).RetrieveOne(ctx, r, ps, dst)
+}
+
+func (c Common) Destroy(ctx context.Context) (*Task, error) {
+	req := types.Destroy_Task{
+		This: c.Reference(),
+	}
+
+	res, err := methods.Destroy_Task(ctx, c.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(c.c, res.Returnval), nil
+}
+
+func (c Common) Rename(ctx context.Context, name string) (*Task, error) {
+	req := types.Rename_Task{
+		This:    c.Reference(),
+		NewName: name,
+	}
+
+	res, err := methods.Rename_Task(ctx, c.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(c.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/common_test.go

@@ -0,0 +1,34 @@
+/*
+Copyright (c) 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 object
+
+import "testing"
+
+func TestCommonName(t *testing.T) {
+	c := &Common{}
+
+	name := c.Name()
+	if name != "" {
+		t.Errorf("Name=%s", name)
+	}
+
+	c.InventoryPath = "/foo/bar"
+	name = c.Name()
+	if name != "bar" {
+		t.Errorf("Name=%s", name)
+	}
+}

vendor/github.com/vmware/govmomi/object/compute_resource.go

@@ -0,0 +1,111 @@
+/*
+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 object
+
+import (
+	"context"
+	"path"
+
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ComputeResource struct {
+	Common
+}
+
+func NewComputeResource(c *vim25.Client, ref types.ManagedObjectReference) *ComputeResource {
+	return &ComputeResource{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (c ComputeResource) Hosts(ctx context.Context) ([]*HostSystem, error) {
+	var cr mo.ComputeResource
+
+	err := c.Properties(ctx, c.Reference(), []string{"host"}, &cr)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(cr.Host) == 0 {
+		return nil, nil
+	}
+
+	var hs []mo.HostSystem
+	pc := property.DefaultCollector(c.Client())
+	err = pc.Retrieve(ctx, cr.Host, []string{"name"}, &hs)
+	if err != nil {
+		return nil, err
+	}
+
+	var hosts []*HostSystem
+
+	for _, h := range hs {
+		host := NewHostSystem(c.Client(), h.Reference())
+		host.InventoryPath = path.Join(c.InventoryPath, h.Name)
+		hosts = append(hosts, host)
+	}
+
+	return hosts, nil
+}
+
+func (c ComputeResource) Datastores(ctx context.Context) ([]*Datastore, error) {
+	var cr mo.ComputeResource
+
+	err := c.Properties(ctx, c.Reference(), []string{"datastore"}, &cr)
+	if err != nil {
+		return nil, err
+	}
+
+	var dss []*Datastore
+	for _, ref := range cr.Datastore {
+		ds := NewDatastore(c.c, ref)
+		dss = append(dss, ds)
+	}
+
+	return dss, nil
+}
+
+func (c ComputeResource) ResourcePool(ctx context.Context) (*ResourcePool, error) {
+	var cr mo.ComputeResource
+
+	err := c.Properties(ctx, c.Reference(), []string{"resourcePool"}, &cr)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewResourcePool(c.c, *cr.ResourcePool), nil
+}
+
+func (c ComputeResource) Reconfigure(ctx context.Context, spec types.BaseComputeResourceConfigSpec, modify bool) (*Task, error) {
+	req := types.ReconfigureComputeResource_Task{
+		This:   c.Reference(),
+		Spec:   spec,
+		Modify: modify,
+	}
+
+	res, err := methods.ReconfigureComputeResource_Task(ctx, c.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(c.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/compute_resource_test.go

@@ -0,0 +1,20 @@
+/*
+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 object
+
+// ComputeResource should implement the Reference interface.
+var _ Reference = ComputeResource{}

vendor/github.com/vmware/govmomi/object/custom_fields_manager.go

@@ -0,0 +1,146 @@
+/*
+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 object
+
+import (
+	"context"
+	"errors"
+	"strconv"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+var (
+	ErrKeyNameNotFound = errors.New("key name not found")
+)
+
+type CustomFieldsManager struct {
+	Common
+}
+
+// GetCustomFieldsManager wraps NewCustomFieldsManager, returning ErrNotSupported
+// when the client is not connected to a vCenter instance.
+func GetCustomFieldsManager(c *vim25.Client) (*CustomFieldsManager, error) {
+	if c.ServiceContent.CustomFieldsManager == nil {
+		return nil, ErrNotSupported
+	}
+	return NewCustomFieldsManager(c), nil
+}
+
+func NewCustomFieldsManager(c *vim25.Client) *CustomFieldsManager {
+	m := CustomFieldsManager{
+		Common: NewCommon(c, *c.ServiceContent.CustomFieldsManager),
+	}
+
+	return &m
+}
+
+func (m CustomFieldsManager) Add(ctx context.Context, name string, moType string, fieldDefPolicy *types.PrivilegePolicyDef, fieldPolicy *types.PrivilegePolicyDef) (*types.CustomFieldDef, error) {
+	req := types.AddCustomFieldDef{
+		This:           m.Reference(),
+		Name:           name,
+		MoType:         moType,
+		FieldDefPolicy: fieldDefPolicy,
+		FieldPolicy:    fieldPolicy,
+	}
+
+	res, err := methods.AddCustomFieldDef(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (m CustomFieldsManager) Remove(ctx context.Context, key int32) error {
+	req := types.RemoveCustomFieldDef{
+		This: m.Reference(),
+		Key:  key,
+	}
+
+	_, err := methods.RemoveCustomFieldDef(ctx, m.c, &req)
+	return err
+}
+
+func (m CustomFieldsManager) Rename(ctx context.Context, key int32, name string) error {
+	req := types.RenameCustomFieldDef{
+		This: m.Reference(),
+		Key:  key,
+		Name: name,
+	}
+
+	_, err := methods.RenameCustomFieldDef(ctx, m.c, &req)
+	return err
+}
+
+func (m CustomFieldsManager) Set(ctx context.Context, entity types.ManagedObjectReference, key int32, value string) error {
+	req := types.SetField{
+		This:   m.Reference(),
+		Entity: entity,
+		Key:    key,
+		Value:  value,
+	}
+
+	_, err := methods.SetField(ctx, m.c, &req)
+	return err
+}
+
+type CustomFieldDefList []types.CustomFieldDef
+
+func (m CustomFieldsManager) Field(ctx context.Context) (CustomFieldDefList, error) {
+	var fm mo.CustomFieldsManager
+
+	err := m.Properties(ctx, m.Reference(), []string{"field"}, &fm)
+	if err != nil {
+		return nil, err
+	}
+
+	return fm.Field, nil
+}
+
+func (m CustomFieldsManager) FindKey(ctx context.Context, name string) (int32, error) {
+	field, err := m.Field(ctx)
+	if err != nil {
+		return -1, err
+	}
+
+	for _, def := range field {
+		if def.Name == name {
+			return def.Key, nil
+		}
+	}
+
+	k, err := strconv.Atoi(name)
+	if err == nil {
+		// assume literal int key
+		return int32(k), nil
+	}
+
+	return -1, ErrKeyNameNotFound
+}
+
+func (l CustomFieldDefList) ByKey(key int32) *types.CustomFieldDef {
+	for _, def := range l {
+		if def.Key == key {
+			return &def
+		}
+	}
+	return nil
+}

vendor/github.com/vmware/govmomi/object/customization_spec_manager.go

@@ -0,0 +1,166 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type CustomizationSpecManager struct {
+	Common
+}
+
+func NewCustomizationSpecManager(c *vim25.Client) *CustomizationSpecManager {
+	cs := CustomizationSpecManager{
+		Common: NewCommon(c, *c.ServiceContent.CustomizationSpecManager),
+	}
+
+	return &cs
+}
+
+func (cs CustomizationSpecManager) DoesCustomizationSpecExist(ctx context.Context, name string) (bool, error) {
+	req := types.DoesCustomizationSpecExist{
+		This: cs.Reference(),
+		Name: name,
+	}
+
+	res, err := methods.DoesCustomizationSpecExist(ctx, cs.c, &req)
+
+	if err != nil {
+		return false, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (cs CustomizationSpecManager) GetCustomizationSpec(ctx context.Context, name string) (*types.CustomizationSpecItem, error) {
+	req := types.GetCustomizationSpec{
+		This: cs.Reference(),
+		Name: name,
+	}
+
+	res, err := methods.GetCustomizationSpec(ctx, cs.c, &req)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (cs CustomizationSpecManager) CreateCustomizationSpec(ctx context.Context, item types.CustomizationSpecItem) error {
+	req := types.CreateCustomizationSpec{
+		This: cs.Reference(),
+		Item: item,
+	}
+
+	_, err := methods.CreateCustomizationSpec(ctx, cs.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cs CustomizationSpecManager) OverwriteCustomizationSpec(ctx context.Context, item types.CustomizationSpecItem) error {
+	req := types.OverwriteCustomizationSpec{
+		This: cs.Reference(),
+		Item: item,
+	}
+
+	_, err := methods.OverwriteCustomizationSpec(ctx, cs.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cs CustomizationSpecManager) DeleteCustomizationSpec(ctx context.Context, name string) error {
+	req := types.DeleteCustomizationSpec{
+		This: cs.Reference(),
+		Name: name,
+	}
+
+	_, err := methods.DeleteCustomizationSpec(ctx, cs.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cs CustomizationSpecManager) DuplicateCustomizationSpec(ctx context.Context, name string, newName string) error {
+	req := types.DuplicateCustomizationSpec{
+		This:    cs.Reference(),
+		Name:    name,
+		NewName: newName,
+	}
+
+	_, err := methods.DuplicateCustomizationSpec(ctx, cs.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cs CustomizationSpecManager) RenameCustomizationSpec(ctx context.Context, name string, newName string) error {
+	req := types.RenameCustomizationSpec{
+		This:    cs.Reference(),
+		Name:    name,
+		NewName: newName,
+	}
+
+	_, err := methods.RenameCustomizationSpec(ctx, cs.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cs CustomizationSpecManager) CustomizationSpecItemToXml(ctx context.Context, item types.CustomizationSpecItem) (string, error) {
+	req := types.CustomizationSpecItemToXml{
+		This: cs.Reference(),
+		Item: item,
+	}
+
+	res, err := methods.CustomizationSpecItemToXml(ctx, cs.c, &req)
+	if err != nil {
+		return "", err
+	}
+
+	return res.Returnval, nil
+}
+
+func (cs CustomizationSpecManager) XmlToCustomizationSpecItem(ctx context.Context, xml string) (*types.CustomizationSpecItem, error) {
+	req := types.XmlToCustomizationSpecItem{
+		This:        cs.Reference(),
+		SpecItemXml: xml,
+	}
+
+	res, err := methods.XmlToCustomizationSpecItem(ctx, cs.c, &req)
+	if err != nil {
+		return nil, err
+	}
+	return &res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/datacenter.go

@@ -0,0 +1,129 @@
+/*
+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 object
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DatacenterFolders struct {
+	VmFolder        *Folder
+	HostFolder      *Folder
+	DatastoreFolder *Folder
+	NetworkFolder   *Folder
+}
+
+type Datacenter struct {
+	Common
+}
+
+func NewDatacenter(c *vim25.Client, ref types.ManagedObjectReference) *Datacenter {
+	return &Datacenter{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (d *Datacenter) Folders(ctx context.Context) (*DatacenterFolders, error) {
+	var md mo.Datacenter
+
+	ps := []string{"name", "vmFolder", "hostFolder", "datastoreFolder", "networkFolder"}
+	err := d.Properties(ctx, d.Reference(), ps, &md)
+	if err != nil {
+		return nil, err
+	}
+
+	df := &DatacenterFolders{
+		VmFolder:        NewFolder(d.c, md.VmFolder),
+		HostFolder:      NewFolder(d.c, md.HostFolder),
+		DatastoreFolder: NewFolder(d.c, md.DatastoreFolder),
+		NetworkFolder:   NewFolder(d.c, md.NetworkFolder),
+	}
+
+	paths := []struct {
+		name string
+		path *string
+	}{
+		{"vm", &df.VmFolder.InventoryPath},
+		{"host", &df.HostFolder.InventoryPath},
+		{"datastore", &df.DatastoreFolder.InventoryPath},
+		{"network", &df.NetworkFolder.InventoryPath},
+	}
+
+	for _, p := range paths {
+		*p.path = fmt.Sprintf("/%s/%s", md.Name, p.name)
+	}
+
+	return df, nil
+}
+
+func (d Datacenter) Destroy(ctx context.Context) (*Task, error) {
+	req := types.Destroy_Task{
+		This: d.Reference(),
+	}
+
+	res, err := methods.Destroy_Task(ctx, d.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(d.c, res.Returnval), nil
+}
+
+// PowerOnVM powers on multiple virtual machines with a single vCenter call.
+// If called against ESX, serially powers on the list of VMs and the returned *Task will always be nil.
+func (d Datacenter) PowerOnVM(ctx context.Context, vm []types.ManagedObjectReference, option ...types.BaseOptionValue) (*Task, error) {
+	if d.Client().IsVC() {
+		req := types.PowerOnMultiVM_Task{
+			This:   d.Reference(),
+			Vm:     vm,
+			Option: option,
+		}
+
+		res, err := methods.PowerOnMultiVM_Task(ctx, d.c, &req)
+		if err != nil {
+			return nil, err
+		}
+
+		return NewTask(d.c, res.Returnval), nil
+	}
+
+	for _, ref := range vm {
+		obj := NewVirtualMachine(d.Client(), ref)
+		task, err := obj.PowerOn(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		err = task.Wait(ctx)
+		if err != nil {
+			// Ignore any InvalidPowerState fault, as it indicates the VM is already powered on
+			if f, ok := err.(types.HasFault); ok {
+				if _, ok = f.Fault().(*types.InvalidPowerState); !ok {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	return nil, nil
+}

vendor/github.com/vmware/govmomi/object/datacenter_test.go

@@ -0,0 +1,20 @@
+/*
+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 object
+
+// Datacenter should implement the Reference interface.
+var _ Reference = Datacenter{}

vendor/github.com/vmware/govmomi/object/datastore.go

@@ -0,0 +1,435 @@
+/*
+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 object
+
+import (
+	"fmt"
+	"io"
+	"math/rand"
+	"os"
+	"path"
+	"strings"
+
+	"context"
+	"net/http"
+	"net/url"
+
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/session"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// DatastoreNoSuchDirectoryError is returned when a directory could not be found.
+type DatastoreNoSuchDirectoryError struct {
+	verb    string
+	subject string
+}
+
+func (e DatastoreNoSuchDirectoryError) Error() string {
+	return fmt.Sprintf("cannot %s '%s': No such directory", e.verb, e.subject)
+}
+
+// DatastoreNoSuchFileError is returned when a file could not be found.
+type DatastoreNoSuchFileError struct {
+	verb    string
+	subject string
+}
+
+func (e DatastoreNoSuchFileError) Error() string {
+	return fmt.Sprintf("cannot %s '%s': No such file", e.verb, e.subject)
+}
+
+type Datastore struct {
+	Common
+
+	DatacenterPath string
+}
+
+func NewDatastore(c *vim25.Client, ref types.ManagedObjectReference) *Datastore {
+	return &Datastore{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (d Datastore) Path(path string) string {
+	return (&DatastorePath{
+		Datastore: d.Name(),
+		Path:      path,
+	}).String()
+}
+
+// NewURL constructs a url.URL with the given file path for datastore access over HTTP.
+func (d Datastore) NewURL(path string) *url.URL {
+	u := d.c.URL()
+
+	return &url.URL{
+		Scheme: u.Scheme,
+		Host:   u.Host,
+		Path:   fmt.Sprintf("/folder/%s", path),
+		RawQuery: url.Values{
+			"dcPath": []string{d.DatacenterPath},
+			"dsName": []string{d.Name()},
+		}.Encode(),
+	}
+}
+
+// URL is deprecated, use NewURL instead.
+func (d Datastore) URL(ctx context.Context, dc *Datacenter, path string) (*url.URL, error) {
+	return d.NewURL(path), nil
+}
+
+func (d Datastore) Browser(ctx context.Context) (*HostDatastoreBrowser, error) {
+	var do mo.Datastore
+
+	err := d.Properties(ctx, d.Reference(), []string{"browser"}, &do)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostDatastoreBrowser(d.c, do.Browser), nil
+}
+
+func (d Datastore) useServiceTicket() bool {
+	// If connected to workstation, service ticketing not supported
+	// If connected to ESX, service ticketing not needed
+	if !d.c.IsVC() {
+		return false
+	}
+
+	key := "GOVMOMI_USE_SERVICE_TICKET"
+
+	val := d.c.URL().Query().Get(key)
+	if val == "" {
+		val = os.Getenv(key)
+	}
+
+	if val == "1" || val == "true" {
+		return true
+	}
+
+	return false
+}
+
+func (d Datastore) useServiceTicketHostName(name string) bool {
+	// No need if talking directly to ESX.
+	if !d.c.IsVC() {
+		return false
+	}
+
+	// If version happens to be < 5.1
+	if name == "" {
+		return false
+	}
+
+	// If the HostSystem is using DHCP on a network without dynamic DNS,
+	// HostSystem.Config.Network.DnsConfig.HostName is set to "localhost" by default.
+	// This resolves to "localhost.localdomain" by default via /etc/hosts on ESX.
+	// In that case, we will stick with the HostSystem.Name which is the IP address that
+	// was used to connect the host to VC.
+	if name == "localhost.localdomain" {
+		return false
+	}
+
+	// Still possible to have HostName that don't resolve via DNS,
+	// so we default to false.
+	key := "GOVMOMI_USE_SERVICE_TICKET_HOSTNAME"
+
+	val := d.c.URL().Query().Get(key)
+	if val == "" {
+		val = os.Getenv(key)
+	}
+
+	if val == "1" || val == "true" {
+		return true
+	}
+
+	return false
+}
+
+type datastoreServiceTicketHostKey struct{}
+
+// HostContext returns a Context where the given host will be used for datastore HTTP access
+// via the ServiceTicket method.
+func (d Datastore) HostContext(ctx context.Context, host *HostSystem) context.Context {
+	return context.WithValue(ctx, datastoreServiceTicketHostKey{}, host)
+}
+
+// ServiceTicket obtains a ticket via AcquireGenericServiceTicket and returns it an http.Cookie with the url.URL
+// that can be used along with the ticket cookie to access the given path.  An host is chosen at random unless the
+// the given Context was created with a specific host via the HostContext method.
+func (d Datastore) ServiceTicket(ctx context.Context, path string, method string) (*url.URL, *http.Cookie, error) {
+	u := d.NewURL(path)
+
+	host, ok := ctx.Value(datastoreServiceTicketHostKey{}).(*HostSystem)
+
+	if !ok {
+		if !d.useServiceTicket() {
+			return u, nil, nil
+		}
+
+		hosts, err := d.AttachedHosts(ctx)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		if len(hosts) == 0 {
+			// Fallback to letting vCenter choose a host
+			return u, nil, nil
+		}
+
+		// Pick a random attached host
+		host = hosts[rand.Intn(len(hosts))]
+	}
+
+	ips, err := host.ManagementIPs(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if len(ips) > 0 {
+		// prefer a ManagementIP
+		u.Host = ips[0].String()
+	} else {
+		// fallback to inventory name
+		u.Host, err = host.ObjectName(ctx)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	// VC datacenter path will not be valid against ESX
+	q := u.Query()
+	delete(q, "dcPath")
+	u.RawQuery = q.Encode()
+
+	spec := types.SessionManagerHttpServiceRequestSpec{
+		Url: u.String(),
+		// See SessionManagerHttpServiceRequestSpecMethod enum
+		Method: fmt.Sprintf("http%s%s", method[0:1], strings.ToLower(method[1:])),
+	}
+
+	sm := session.NewManager(d.Client())
+
+	ticket, err := sm.AcquireGenericServiceTicket(ctx, &spec)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cookie := &http.Cookie{
+		Name:  "vmware_cgi_ticket",
+		Value: ticket.Id,
+	}
+
+	if d.useServiceTicketHostName(ticket.HostName) {
+		u.Host = ticket.HostName
+	}
+
+	d.Client().SetThumbprint(u.Host, ticket.SslThumbprint)
+
+	return u, cookie, nil
+}
+
+func (d Datastore) uploadTicket(ctx context.Context, path string, param *soap.Upload) (*url.URL, *soap.Upload, error) {
+	p := soap.DefaultUpload
+	if param != nil {
+		p = *param // copy
+	}
+
+	u, ticket, err := d.ServiceTicket(ctx, path, p.Method)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p.Ticket = ticket
+
+	return u, &p, nil
+}
+
+func (d Datastore) downloadTicket(ctx context.Context, path string, param *soap.Download) (*url.URL, *soap.Download, error) {
+	p := soap.DefaultDownload
+	if param != nil {
+		p = *param // copy
+	}
+
+	u, ticket, err := d.ServiceTicket(ctx, path, p.Method)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p.Ticket = ticket
+
+	return u, &p, nil
+}
+
+// Upload via soap.Upload with an http service ticket
+func (d Datastore) Upload(ctx context.Context, f io.Reader, path string, param *soap.Upload) error {
+	u, p, err := d.uploadTicket(ctx, path, param)
+	if err != nil {
+		return err
+	}
+	return d.Client().Upload(ctx, f, u, p)
+}
+
+// UploadFile via soap.Upload with an http service ticket
+func (d Datastore) UploadFile(ctx context.Context, file string, path string, param *soap.Upload) error {
+	u, p, err := d.uploadTicket(ctx, path, param)
+	if err != nil {
+		return err
+	}
+	return d.Client().UploadFile(ctx, file, u, p)
+}
+
+// Download via soap.Download with an http service ticket
+func (d Datastore) Download(ctx context.Context, path string, param *soap.Download) (io.ReadCloser, int64, error) {
+	u, p, err := d.downloadTicket(ctx, path, param)
+	if err != nil {
+		return nil, 0, err
+	}
+	return d.Client().Download(ctx, u, p)
+}
+
+// DownloadFile via soap.Download with an http service ticket
+func (d Datastore) DownloadFile(ctx context.Context, path string, file string, param *soap.Download) error {
+	u, p, err := d.downloadTicket(ctx, path, param)
+	if err != nil {
+		return err
+	}
+	return d.Client().DownloadFile(ctx, file, u, p)
+}
+
+// AttachedHosts returns hosts that have this Datastore attached, accessible and writable.
+func (d Datastore) AttachedHosts(ctx context.Context) ([]*HostSystem, error) {
+	var ds mo.Datastore
+	var hosts []*HostSystem
+
+	pc := property.DefaultCollector(d.Client())
+	err := pc.RetrieveOne(ctx, d.Reference(), []string{"host"}, &ds)
+	if err != nil {
+		return nil, err
+	}
+
+	mounts := make(map[types.ManagedObjectReference]types.DatastoreHostMount)
+	var refs []types.ManagedObjectReference
+	for _, host := range ds.Host {
+		refs = append(refs, host.Key)
+		mounts[host.Key] = host
+	}
+
+	var hs []mo.HostSystem
+	err = pc.Retrieve(ctx, refs, []string{"runtime.connectionState", "runtime.powerState"}, &hs)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, host := range hs {
+		if host.Runtime.ConnectionState == types.HostSystemConnectionStateConnected &&
+			host.Runtime.PowerState == types.HostSystemPowerStatePoweredOn {
+
+			mount := mounts[host.Reference()]
+			info := mount.MountInfo
+
+			if *info.Mounted && *info.Accessible && info.AccessMode == string(types.HostMountModeReadWrite) {
+				hosts = append(hosts, NewHostSystem(d.Client(), mount.Key))
+			}
+		}
+	}
+
+	return hosts, nil
+}
+
+// AttachedClusterHosts returns hosts that have this Datastore attached, accessible and writable and are members of the given cluster.
+func (d Datastore) AttachedClusterHosts(ctx context.Context, cluster *ComputeResource) ([]*HostSystem, error) {
+	var hosts []*HostSystem
+
+	clusterHosts, err := cluster.Hosts(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	attachedHosts, err := d.AttachedHosts(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	refs := make(map[types.ManagedObjectReference]bool)
+	for _, host := range attachedHosts {
+		refs[host.Reference()] = true
+	}
+
+	for _, host := range clusterHosts {
+		if refs[host.Reference()] {
+			hosts = append(hosts, host)
+		}
+	}
+
+	return hosts, nil
+}
+
+func (d Datastore) Stat(ctx context.Context, file string) (types.BaseFileInfo, error) {
+	b, err := d.Browser(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	spec := types.HostDatastoreBrowserSearchSpec{
+		Details: &types.FileQueryFlags{
+			FileType:     true,
+			FileSize:     true,
+			Modification: true,
+			FileOwner:    types.NewBool(true),
+		},
+		MatchPattern: []string{path.Base(file)},
+	}
+
+	dsPath := d.Path(path.Dir(file))
+	task, err := b.SearchDatastore(ctx, dsPath, &spec)
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := task.WaitForResult(ctx, nil)
+	if err != nil {
+		if types.IsFileNotFound(err) {
+			// FileNotFound means the base path doesn't exist.
+			return nil, DatastoreNoSuchDirectoryError{"stat", dsPath}
+		}
+
+		return nil, err
+	}
+
+	res := info.Result.(types.HostDatastoreBrowserSearchResults)
+	if len(res.File) == 0 {
+		// File doesn't exist
+		return nil, DatastoreNoSuchFileError{"stat", d.Path(file)}
+	}
+
+	return res.File[0], nil
+
+}
+
+// Type returns the type of file system volume.
+func (d Datastore) Type(ctx context.Context) (types.HostFileSystemVolumeFileSystemType, error) {
+	var mds mo.Datastore
+
+	if err := d.Properties(ctx, d.Reference(), []string{"summary.type"}, &mds); err != nil {
+		return types.HostFileSystemVolumeFileSystemType(""), err
+	}
+	return types.HostFileSystemVolumeFileSystemType(mds.Summary.Type), nil
+}

vendor/github.com/vmware/govmomi/object/datastore_file.go

@@ -0,0 +1,414 @@
+/*
+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 object
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"sync"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+// DatastoreFile implements io.Reader, io.Seeker and io.Closer interfaces for datastore file access.
+type DatastoreFile struct {
+	d    Datastore
+	ctx  context.Context
+	name string
+
+	buf    io.Reader
+	body   io.ReadCloser
+	length int64
+	offset struct {
+		read, seek int64
+	}
+}
+
+// Open opens the named file relative to the Datastore.
+func (d Datastore) Open(ctx context.Context, name string) (*DatastoreFile, error) {
+	return &DatastoreFile{
+		d:      d,
+		name:   name,
+		length: -1,
+		ctx:    ctx,
+	}, nil
+}
+
+// Read reads up to len(b) bytes from the DatastoreFile.
+func (f *DatastoreFile) Read(b []byte) (int, error) {
+	if f.offset.read != f.offset.seek {
+		// A Seek() call changed the offset, we need to issue a new GET
+		_ = f.Close()
+
+		f.offset.read = f.offset.seek
+	} else if f.buf != nil {
+		// f.buf + f behaves like an io.MultiReader
+		n, err := f.buf.Read(b)
+		if err == io.EOF {
+			f.buf = nil // buffer has been drained
+		}
+		if n > 0 {
+			return n, nil
+		}
+	}
+
+	body, err := f.get()
+	if err != nil {
+		return 0, err
+	}
+
+	n, err := body.Read(b)
+
+	f.offset.read += int64(n)
+	f.offset.seek += int64(n)
+
+	return n, err
+}
+
+// Close closes the DatastoreFile.
+func (f *DatastoreFile) Close() error {
+	var err error
+
+	if f.body != nil {
+		err = f.body.Close()
+		f.body = nil
+	}
+
+	f.buf = nil
+
+	return err
+}
+
+// Seek sets the offset for the next Read on the DatastoreFile.
+func (f *DatastoreFile) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	case io.SeekStart:
+	case io.SeekCurrent:
+		offset += f.offset.seek
+	case io.SeekEnd:
+		if f.length < 0 {
+			_, err := f.Stat()
+			if err != nil {
+				return 0, err
+			}
+		}
+		offset += f.length
+	default:
+		return 0, errors.New("Seek: invalid whence")
+	}
+
+	// allow negative SeekStart for initial Range request
+	if offset < 0 {
+		return 0, errors.New("Seek: invalid offset")
+	}
+
+	f.offset.seek = offset
+
+	return offset, nil
+}
+
+type fileStat struct {
+	file   *DatastoreFile
+	header http.Header
+}
+
+func (s *fileStat) Name() string {
+	return path.Base(s.file.name)
+}
+
+func (s *fileStat) Size() int64 {
+	return s.file.length
+}
+
+func (s *fileStat) Mode() os.FileMode {
+	return 0
+}
+
+func (s *fileStat) ModTime() time.Time {
+	return time.Now() // no Last-Modified
+}
+
+func (s *fileStat) IsDir() bool {
+	return false
+}
+
+func (s *fileStat) Sys() interface{} {
+	return s.header
+}
+
+func statusError(res *http.Response) error {
+	if res.StatusCode == http.StatusNotFound {
+		return os.ErrNotExist
+	}
+	return errors.New(res.Status)
+}
+
+// Stat returns the os.FileInfo interface describing file.
+func (f *DatastoreFile) Stat() (os.FileInfo, error) {
+	// TODO: consider using Datastore.Stat() instead
+	u, p, err := f.d.downloadTicket(f.ctx, f.name, &soap.Download{Method: "HEAD"})
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := f.d.Client().DownloadRequest(f.ctx, u, p)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return nil, statusError(res)
+	}
+
+	f.length = res.ContentLength
+
+	return &fileStat{f, res.Header}, nil
+}
+
+func (f *DatastoreFile) get() (io.Reader, error) {
+	if f.body != nil {
+		return f.body, nil
+	}
+
+	u, p, err := f.d.downloadTicket(f.ctx, f.name, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if f.offset.read != 0 {
+		p.Headers = map[string]string{
+			"Range": fmt.Sprintf("bytes=%d-", f.offset.read),
+		}
+	}
+
+	res, err := f.d.Client().DownloadRequest(f.ctx, u, p)
+	if err != nil {
+		return nil, err
+	}
+
+	switch res.StatusCode {
+	case http.StatusOK:
+		f.length = res.ContentLength
+	case http.StatusPartialContent:
+		var start, end int
+		cr := res.Header.Get("Content-Range")
+		_, err = fmt.Sscanf(cr, "bytes %d-%d/%d", &start, &end, &f.length)
+		if err != nil {
+			f.length = -1
+		}
+	case http.StatusRequestedRangeNotSatisfiable:
+		// ok: Read() will return io.EOF
+	default:
+		return nil, statusError(res)
+	}
+
+	if f.length < 0 {
+		_ = res.Body.Close()
+		return nil, errors.New("unable to determine file size")
+	}
+
+	f.body = res.Body
+
+	return f.body, nil
+}
+
+func lastIndexLines(s []byte, line *int, include func(l int, m string) bool) (int64, bool) {
+	i := len(s) - 1
+	done := false
+
+	for i > 0 {
+		o := bytes.LastIndexByte(s[:i], '\n')
+		if o < 0 {
+			break
+		}
+
+		msg := string(s[o+1 : i+1])
+		if !include(*line, msg) {
+			done = true
+			break
+		} else {
+			i = o
+			*line++
+		}
+	}
+
+	return int64(i), done
+}
+
+// Tail seeks to the position of the last N lines of the file.
+func (f *DatastoreFile) Tail(n int) error {
+	return f.TailFunc(n, func(line int, _ string) bool { return n > line })
+}
+
+// TailFunc will seek backwards in the datastore file until it hits a line that does
+// not satisfy the supplied `include` function.
+func (f *DatastoreFile) TailFunc(lines int, include func(line int, message string) bool) error {
+	// Read the file in reverse using bsize chunks
+	const bsize = int64(1024 * 16)
+
+	fsize, err := f.Seek(0, io.SeekEnd)
+	if err != nil {
+		return err
+	}
+
+	if lines == 0 {
+		return nil
+	}
+
+	chunk := int64(-1)
+
+	buf := bytes.NewBuffer(make([]byte, 0, bsize))
+	line := 0
+
+	for {
+		var eof bool
+		var pos int64
+
+		nread := bsize
+
+		offset := chunk * bsize
+		remain := fsize + offset
+
+		if remain < 0 {
+			if pos, err = f.Seek(0, io.SeekStart); err != nil {
+				return err
+			}
+
+			nread = bsize + remain
+			eof = true
+		} else {
+			if pos, err = f.Seek(offset, io.SeekEnd); err != nil {
+				return err
+			}
+		}
+
+		if _, err = io.CopyN(buf, f, nread); err != nil {
+			if err != io.EOF {
+				return err
+			}
+		}
+
+		b := buf.Bytes()
+		idx, done := lastIndexLines(b, &line, include)
+
+		if done {
+			if chunk == -1 {
+				// We found all N lines in the last chunk of the file.
+				// The seek offset is also now at the current end of file.
+				// Save this buffer to avoid another GET request when Read() is called.
+				buf.Next(int(idx + 1))
+				f.buf = buf
+				return nil
+			}
+
+			if _, err = f.Seek(pos+idx+1, io.SeekStart); err != nil {
+				return err
+			}
+
+			break
+		}
+
+		if eof {
+			if remain < 0 {
+				// We found < N lines in the entire file, so seek to the start.
+				_, _ = f.Seek(0, io.SeekStart)
+			}
+			break
+		}
+
+		chunk--
+		buf.Reset()
+	}
+
+	return nil
+}
+
+type followDatastoreFile struct {
+	r *DatastoreFile
+	c chan struct{}
+	i time.Duration
+	o sync.Once
+}
+
+// Read reads up to len(b) bytes from the DatastoreFile being followed.
+// This method will block until data is read, an error other than io.EOF is returned or Close() is called.
+func (f *followDatastoreFile) Read(p []byte) (int, error) {
+	offset := f.r.offset.seek
+	stop := false
+
+	for {
+		n, err := f.r.Read(p)
+		if err != nil && err == io.EOF {
+			_ = f.r.Close() // GET request body has been drained.
+			if stop {
+				return n, err
+			}
+			err = nil
+		}
+
+		if n > 0 {
+			return n, err
+		}
+
+		select {
+		case <-f.c:
+			// Wake up and stop polling once the body has been drained
+			stop = true
+		case <-time.After(f.i):
+		}
+
+		info, serr := f.r.Stat()
+		if serr != nil {
+			// Return EOF rather than 404 if the file goes away
+			if serr == os.ErrNotExist {
+				_ = f.r.Close()
+				return 0, io.EOF
+			}
+			return 0, serr
+		}
+
+		if info.Size() < offset {
+			// assume file has be truncated
+			offset, err = f.r.Seek(0, io.SeekStart)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+}
+
+// Close will stop Follow polling and close the underlying DatastoreFile.
+func (f *followDatastoreFile) Close() error {
+	f.o.Do(func() { close(f.c) })
+	return nil
+}
+
+// Follow returns an io.ReadCloser to stream the file contents as data is appended.
+func (f *DatastoreFile) Follow(interval time.Duration) io.ReadCloser {
+	return &followDatastoreFile{
+		r: f,
+		c: make(chan struct{}),
+		i: interval,
+	}
+}

vendor/github.com/vmware/govmomi/object/datastore_file_manager.go

@@ -0,0 +1,228 @@
+/*
+Copyright (c) 2017-2018 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 object
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"log"
+	"path"
+	"strings"
+
+	"github.com/vmware/govmomi/vim25/progress"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+// DatastoreFileManager combines FileManager and VirtualDiskManager to manage files on a Datastore
+type DatastoreFileManager struct {
+	Datacenter         *Datacenter
+	Datastore          *Datastore
+	FileManager        *FileManager
+	VirtualDiskManager *VirtualDiskManager
+
+	Force            bool
+	DatacenterTarget *Datacenter
+}
+
+// NewFileManager creates a new instance of DatastoreFileManager
+func (d Datastore) NewFileManager(dc *Datacenter, force bool) *DatastoreFileManager {
+	c := d.Client()
+
+	m := &DatastoreFileManager{
+		Datacenter:         dc,
+		Datastore:          &d,
+		FileManager:        NewFileManager(c),
+		VirtualDiskManager: NewVirtualDiskManager(c),
+		Force:              force,
+		DatacenterTarget:   dc,
+	}
+
+	return m
+}
+
+func (m *DatastoreFileManager) WithProgress(ctx context.Context, s progress.Sinker) context.Context {
+	return context.WithValue(ctx, m, s)
+}
+
+func (m *DatastoreFileManager) wait(ctx context.Context, task *Task) error {
+	var logger progress.Sinker
+	if s, ok := ctx.Value(m).(progress.Sinker); ok {
+		logger = s
+	}
+	_, err := task.WaitForResult(ctx, logger)
+	return err
+}
+
+// Delete dispatches to the appropriate Delete method based on file name extension
+func (m *DatastoreFileManager) Delete(ctx context.Context, name string) error {
+	switch path.Ext(name) {
+	case ".vmdk":
+		return m.DeleteVirtualDisk(ctx, name)
+	default:
+		return m.DeleteFile(ctx, name)
+	}
+}
+
+// DeleteFile calls FileManager.DeleteDatastoreFile
+func (m *DatastoreFileManager) DeleteFile(ctx context.Context, name string) error {
+	p := m.Path(name)
+
+	task, err := m.FileManager.DeleteDatastoreFile(ctx, p.String(), m.Datacenter)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// DeleteVirtualDisk calls VirtualDiskManager.DeleteVirtualDisk
+// Regardless of the Datastore type, DeleteVirtualDisk will fail if 'ddb.deletable=false',
+// so if Force=true this method attempts to set 'ddb.deletable=true' before starting the delete task.
+func (m *DatastoreFileManager) DeleteVirtualDisk(ctx context.Context, name string) error {
+	p := m.Path(name)
+
+	var merr error
+
+	if m.Force {
+		merr = m.markDiskAsDeletable(ctx, p)
+	}
+
+	task, err := m.VirtualDiskManager.DeleteVirtualDisk(ctx, p.String(), m.Datacenter)
+	if err != nil {
+		log.Printf("markDiskAsDeletable(%s): %s", p, merr)
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// CopyFile calls FileManager.CopyDatastoreFile
+func (m *DatastoreFileManager) CopyFile(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	task, err := m.FileManager.CopyDatastoreFile(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// Copy dispatches to the appropriate FileManager or VirtualDiskManager Copy method based on file name extension
+func (m *DatastoreFileManager) Copy(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	f := m.FileManager.CopyDatastoreFile
+
+	if srcp.IsVMDK() {
+		// types.VirtualDiskSpec=nil as it is not implemented by vCenter
+		f = func(ctx context.Context, src string, srcDC *Datacenter, dst string, dstDC *Datacenter, force bool) (*Task, error) {
+			return m.VirtualDiskManager.CopyVirtualDisk(ctx, src, srcDC, dst, dstDC, nil, force)
+		}
+	}
+
+	task, err := f(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// MoveFile calls FileManager.MoveDatastoreFile
+func (m *DatastoreFileManager) MoveFile(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	task, err := m.FileManager.MoveDatastoreFile(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// Move dispatches to the appropriate FileManager or VirtualDiskManager Move method based on file name extension
+func (m *DatastoreFileManager) Move(ctx context.Context, src string, dst string) error {
+	srcp := m.Path(src)
+	dstp := m.Path(dst)
+
+	f := m.FileManager.MoveDatastoreFile
+
+	if srcp.IsVMDK() {
+		f = m.VirtualDiskManager.MoveVirtualDisk
+	}
+
+	task, err := f(ctx, srcp.String(), m.Datacenter, dstp.String(), m.DatacenterTarget, m.Force)
+	if err != nil {
+		return err
+	}
+
+	return m.wait(ctx, task)
+}
+
+// Path converts path name to a DatastorePath
+func (m *DatastoreFileManager) Path(name string) *DatastorePath {
+	var p DatastorePath
+
+	if !p.FromString(name) {
+		p.Path = name
+		p.Datastore = m.Datastore.Name()
+	}
+
+	return &p
+}
+
+func (m *DatastoreFileManager) markDiskAsDeletable(ctx context.Context, path *DatastorePath) error {
+	r, _, err := m.Datastore.Download(ctx, path.Path, &soap.DefaultDownload)
+	if err != nil {
+		return err
+	}
+
+	defer r.Close()
+
+	hasFlag := false
+	buf := new(bytes.Buffer)
+
+	s := bufio.NewScanner(&io.LimitedReader{R: r, N: 2048}) // should be only a few hundred bytes, limit to be sure
+
+	for s.Scan() {
+		line := s.Text()
+		if strings.HasPrefix(line, "ddb.deletable") {
+			hasFlag = true
+			continue
+		}
+
+		fmt.Fprintln(buf, line)
+	}
+
+	if err := s.Err(); err != nil {
+		return err // any error other than EOF
+	}
+
+	if !hasFlag {
+		return nil // already deletable, so leave as-is
+	}
+
+	// rewrite the .vmdk with ddb.deletable flag removed (the default is true)
+	return m.Datastore.Upload(ctx, buf, path.Path, &soap.DefaultUpload)
+}

vendor/github.com/vmware/govmomi/object/datastore_path.go

@@ -0,0 +1,71 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"fmt"
+	"path"
+	"strings"
+)
+
+// DatastorePath contains the components of a datastore path.
+type DatastorePath struct {
+	Datastore string
+	Path      string
+}
+
+// FromString parses a datastore path.
+// Returns true if the path could be parsed, false otherwise.
+func (p *DatastorePath) FromString(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+
+	s = strings.TrimSpace(s)
+
+	if !strings.HasPrefix(s, "[") {
+		return false
+	}
+
+	s = s[1:]
+
+	ix := strings.Index(s, "]")
+	if ix < 0 {
+		return false
+	}
+
+	p.Datastore = s[:ix]
+	p.Path = strings.TrimSpace(s[ix+1:])
+
+	return true
+}
+
+// String formats a datastore path.
+func (p *DatastorePath) String() string {
+	s := fmt.Sprintf("[%s]", p.Datastore)
+
+	if p.Path == "" {
+		return s
+	}
+
+	return strings.Join([]string{s, p.Path}, " ")
+}
+
+// IsVMDK returns true if Path has a ".vmdk" extension
+func (p *DatastorePath) IsVMDK() bool {
+	return path.Ext(p.Path) == ".vmdk"
+}

vendor/github.com/vmware/govmomi/object/datastore_path_test.go

@@ -0,0 +1,76 @@
+/*
+Copyright (c) 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 object
+
+import "testing"
+
+func TestParseDatastorePath(t *testing.T) {
+	tests := []struct {
+		dsPath string
+		dsFile string
+		fail   bool
+	}{
+		{"", "", true},
+		{"x", "", true},
+		{"[", "", true},
+		{"[nope", "", true},
+		{"[te st]", "", false},
+		{"[te st] foo", "foo", false},
+		{"[te st] foo/foo.vmx", "foo/foo.vmx", false},
+		{"[te st]foo bar/foo bar.vmx", "foo bar/foo bar.vmx", false},
+		{" [te st]     bar/bar.vmx  ", "bar/bar.vmx", false},
+	}
+
+	for _, test := range tests {
+		p := new(DatastorePath)
+		ok := p.FromString(test.dsPath)
+
+		if test.fail {
+			if ok {
+				t.Errorf("expected error for: %s", test.dsPath)
+			}
+		} else {
+			if !ok {
+				t.Errorf("failed to parse: %q", test.dsPath)
+			} else {
+				if test.dsFile != p.Path {
+					t.Errorf("dsFile=%s", p.Path)
+				}
+				if p.Datastore != "te st" {
+					t.Errorf("ds=%s", p.Datastore)
+				}
+			}
+		}
+	}
+
+	s := "[datastore1] foo/bar.vmdk"
+	p := new(DatastorePath)
+	ok := p.FromString(s)
+	if !ok {
+		t.Fatal(s)
+	}
+
+	if p.String() != s {
+		t.Fatal(p.String())
+	}
+
+	p.Path = ""
+
+	if p.String() != "[datastore1]" {
+		t.Fatal(p.String())
+	}
+}

vendor/github.com/vmware/govmomi/object/datastore_test.go

@@ -0,0 +1,20 @@
+/*
+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 object
+
+// Datastore should implement the Reference interface.
+var _ Reference = Datastore{}

vendor/github.com/vmware/govmomi/object/diagnostic_log.go

@@ -0,0 +1,76 @@
+/*
+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 object
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"math"
+)
+
+// DiagnosticLog wraps DiagnosticManager.BrowseLog
+type DiagnosticLog struct {
+	m DiagnosticManager
+
+	Key  string
+	Host *HostSystem
+
+	Start int32
+}
+
+// Seek to log position starting at the last nlines of the log
+func (l *DiagnosticLog) Seek(ctx context.Context, nlines int32) error {
+	h, err := l.m.BrowseLog(ctx, l.Host, l.Key, math.MaxInt32, 0)
+	if err != nil {
+		return err
+	}
+
+	l.Start = h.LineEnd - nlines
+
+	return nil
+}
+
+// Copy log starting from l.Start to the given io.Writer
+// Returns on error or when end of log is reached.
+func (l *DiagnosticLog) Copy(ctx context.Context, w io.Writer) (int, error) {
+	const max = 500 // VC max == 500, ESX max == 1000
+	written := 0
+
+	for {
+		h, err := l.m.BrowseLog(ctx, l.Host, l.Key, l.Start, max)
+		if err != nil {
+			return 0, err
+		}
+
+		for _, line := range h.LineText {
+			n, err := fmt.Fprintln(w, line)
+			written += n
+			if err != nil {
+				return written, err
+			}
+		}
+
+		l.Start += int32(len(h.LineText))
+
+		if l.Start >= h.LineEnd {
+			break
+		}
+	}
+
+	return written, nil
+}

vendor/github.com/vmware/govmomi/object/diagnostic_manager.go

@@ -0,0 +1,104 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DiagnosticManager struct {
+	Common
+}
+
+func NewDiagnosticManager(c *vim25.Client) *DiagnosticManager {
+	m := DiagnosticManager{
+		Common: NewCommon(c, *c.ServiceContent.DiagnosticManager),
+	}
+
+	return &m
+}
+
+func (m DiagnosticManager) Log(ctx context.Context, host *HostSystem, key string) *DiagnosticLog {
+	return &DiagnosticLog{
+		m:    m,
+		Key:  key,
+		Host: host,
+	}
+}
+
+func (m DiagnosticManager) BrowseLog(ctx context.Context, host *HostSystem, key string, start, lines int32) (*types.DiagnosticManagerLogHeader, error) {
+	req := types.BrowseDiagnosticLog{
+		This:  m.Reference(),
+		Key:   key,
+		Start: start,
+		Lines: lines,
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	res, err := methods.BrowseDiagnosticLog(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (m DiagnosticManager) GenerateLogBundles(ctx context.Context, includeDefault bool, host []*HostSystem) (*Task, error) {
+	req := types.GenerateLogBundles_Task{
+		This:           m.Reference(),
+		IncludeDefault: includeDefault,
+	}
+
+	if host != nil {
+		for _, h := range host {
+			req.Host = append(req.Host, h.Reference())
+		}
+	}
+
+	res, err := methods.GenerateLogBundles_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+func (m DiagnosticManager) QueryDescriptions(ctx context.Context, host *HostSystem) ([]types.DiagnosticManagerLogDescriptor, error) {
+	req := types.QueryDescriptions{
+		This: m.Reference(),
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	res, err := methods.QueryDescriptions(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/distributed_virtual_portgroup.go

@@ -0,0 +1,73 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DistributedVirtualPortgroup struct {
+	Common
+}
+
+func NewDistributedVirtualPortgroup(c *vim25.Client, ref types.ManagedObjectReference) *DistributedVirtualPortgroup {
+	return &DistributedVirtualPortgroup{
+		Common: NewCommon(c, ref),
+	}
+}
+
+// EthernetCardBackingInfo returns the VirtualDeviceBackingInfo for this DistributedVirtualPortgroup
+func (p DistributedVirtualPortgroup) EthernetCardBackingInfo(ctx context.Context) (types.BaseVirtualDeviceBackingInfo, error) {
+	var dvp mo.DistributedVirtualPortgroup
+	var dvs mo.DistributedVirtualSwitch
+
+	if err := p.Properties(ctx, p.Reference(), []string{"key", "config.distributedVirtualSwitch"}, &dvp); err != nil {
+		return nil, err
+	}
+
+	if err := p.Properties(ctx, *dvp.Config.DistributedVirtualSwitch, []string{"uuid"}, &dvs); err != nil {
+		return nil, err
+	}
+
+	backing := &types.VirtualEthernetCardDistributedVirtualPortBackingInfo{
+		Port: types.DistributedVirtualSwitchPortConnection{
+			PortgroupKey: dvp.Key,
+			SwitchUuid:   dvs.Uuid,
+		},
+	}
+
+	return backing, nil
+}
+
+func (p DistributedVirtualPortgroup) Reconfigure(ctx context.Context, spec types.DVPortgroupConfigSpec) (*Task, error) {
+	req := types.ReconfigureDVPortgroup_Task{
+		This: p.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.ReconfigureDVPortgroup_Task(ctx, p.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(p.Client(), res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/distributed_virtual_portgroup_test.go

@@ -0,0 +1,23 @@
+/*
+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 object
+
+// DistributedVirtualPortgroup should implement the Reference interface.
+var _ Reference = DistributedVirtualPortgroup{}
+
+// DistributedVirtualPortgroup should implement the NetworkReference interface.
+var _ NetworkReference = DistributedVirtualPortgroup{}

vendor/github.com/vmware/govmomi/object/distributed_virtual_switch.go

@@ -0,0 +1,80 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DistributedVirtualSwitch struct {
+	Common
+}
+
+func NewDistributedVirtualSwitch(c *vim25.Client, ref types.ManagedObjectReference) *DistributedVirtualSwitch {
+	return &DistributedVirtualSwitch{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s DistributedVirtualSwitch) EthernetCardBackingInfo(ctx context.Context) (types.BaseVirtualDeviceBackingInfo, error) {
+	return nil, ErrNotSupported // TODO: just to satisfy NetworkReference interface for the finder
+}
+
+func (s DistributedVirtualSwitch) Reconfigure(ctx context.Context, spec types.BaseDVSConfigSpec) (*Task, error) {
+	req := types.ReconfigureDvs_Task{
+		This: s.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.ReconfigureDvs_Task(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.Client(), res.Returnval), nil
+}
+
+func (s DistributedVirtualSwitch) AddPortgroup(ctx context.Context, spec []types.DVPortgroupConfigSpec) (*Task, error) {
+	req := types.AddDVPortgroup_Task{
+		This: s.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.AddDVPortgroup_Task(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.Client(), res.Returnval), nil
+}
+
+func (s DistributedVirtualSwitch) FetchDVPorts(ctx context.Context, criteria *types.DistributedVirtualSwitchPortCriteria) ([]types.DistributedVirtualPort, error) {
+	req := &types.FetchDVPorts{
+		This:     s.Reference(),
+		Criteria: criteria,
+	}
+
+	res, err := methods.FetchDVPorts(ctx, s.Client(), req)
+	if err != nil {
+		return nil, err
+	}
+	return res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/extension_manager.go

@@ -0,0 +1,113 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ExtensionManager struct {
+	Common
+}
+
+// GetExtensionManager wraps NewExtensionManager, returning ErrNotSupported
+// when the client is not connected to a vCenter instance.
+func GetExtensionManager(c *vim25.Client) (*ExtensionManager, error) {
+	if c.ServiceContent.ExtensionManager == nil {
+		return nil, ErrNotSupported
+	}
+	return NewExtensionManager(c), nil
+}
+
+func NewExtensionManager(c *vim25.Client) *ExtensionManager {
+	o := ExtensionManager{
+		Common: NewCommon(c, *c.ServiceContent.ExtensionManager),
+	}
+
+	return &o
+}
+
+func (m ExtensionManager) List(ctx context.Context) ([]types.Extension, error) {
+	var em mo.ExtensionManager
+
+	err := m.Properties(ctx, m.Reference(), []string{"extensionList"}, &em)
+	if err != nil {
+		return nil, err
+	}
+
+	return em.ExtensionList, nil
+}
+
+func (m ExtensionManager) Find(ctx context.Context, key string) (*types.Extension, error) {
+	req := types.FindExtension{
+		This:         m.Reference(),
+		ExtensionKey: key,
+	}
+
+	res, err := methods.FindExtension(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (m ExtensionManager) Register(ctx context.Context, extension types.Extension) error {
+	req := types.RegisterExtension{
+		This:      m.Reference(),
+		Extension: extension,
+	}
+
+	_, err := methods.RegisterExtension(ctx, m.c, &req)
+	return err
+}
+
+func (m ExtensionManager) SetCertificate(ctx context.Context, key string, certificatePem string) error {
+	req := types.SetExtensionCertificate{
+		This:           m.Reference(),
+		ExtensionKey:   key,
+		CertificatePem: certificatePem,
+	}
+
+	_, err := methods.SetExtensionCertificate(ctx, m.c, &req)
+	return err
+}
+
+func (m ExtensionManager) Unregister(ctx context.Context, key string) error {
+	req := types.UnregisterExtension{
+		This:         m.Reference(),
+		ExtensionKey: key,
+	}
+
+	_, err := methods.UnregisterExtension(ctx, m.c, &req)
+	return err
+}
+
+func (m ExtensionManager) Update(ctx context.Context, extension types.Extension) error {
+	req := types.UpdateExtension{
+		This:      m.Reference(),
+		Extension: extension,
+	}
+
+	_, err := methods.UpdateExtension(ctx, m.c, &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/file_manager.go

@@ -0,0 +1,126 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type FileManager struct {
+	Common
+}
+
+func NewFileManager(c *vim25.Client) *FileManager {
+	f := FileManager{
+		Common: NewCommon(c, *c.ServiceContent.FileManager),
+	}
+
+	return &f
+}
+
+func (f FileManager) CopyDatastoreFile(ctx context.Context, sourceName string, sourceDatacenter *Datacenter, destinationName string, destinationDatacenter *Datacenter, force bool) (*Task, error) {
+	req := types.CopyDatastoreFile_Task{
+		This:            f.Reference(),
+		SourceName:      sourceName,
+		DestinationName: destinationName,
+		Force:           types.NewBool(force),
+	}
+
+	if sourceDatacenter != nil {
+		ref := sourceDatacenter.Reference()
+		req.SourceDatacenter = &ref
+	}
+
+	if destinationDatacenter != nil {
+		ref := destinationDatacenter.Reference()
+		req.DestinationDatacenter = &ref
+	}
+
+	res, err := methods.CopyDatastoreFile_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}
+
+// DeleteDatastoreFile deletes the specified file or folder from the datastore.
+func (f FileManager) DeleteDatastoreFile(ctx context.Context, name string, dc *Datacenter) (*Task, error) {
+	req := types.DeleteDatastoreFile_Task{
+		This: f.Reference(),
+		Name: name,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.DeleteDatastoreFile_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}
+
+// MakeDirectory creates a folder using the specified name.
+func (f FileManager) MakeDirectory(ctx context.Context, name string, dc *Datacenter, createParentDirectories bool) error {
+	req := types.MakeDirectory{
+		This: f.Reference(),
+		Name: name,
+		CreateParentDirectories: types.NewBool(createParentDirectories),
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	_, err := methods.MakeDirectory(ctx, f.c, &req)
+	return err
+}
+
+func (f FileManager) MoveDatastoreFile(ctx context.Context, sourceName string, sourceDatacenter *Datacenter, destinationName string, destinationDatacenter *Datacenter, force bool) (*Task, error) {
+	req := types.MoveDatastoreFile_Task{
+		This:            f.Reference(),
+		SourceName:      sourceName,
+		DestinationName: destinationName,
+		Force:           types.NewBool(force),
+	}
+
+	if sourceDatacenter != nil {
+		ref := sourceDatacenter.Reference()
+		req.SourceDatacenter = &ref
+	}
+
+	if destinationDatacenter != nil {
+		ref := destinationDatacenter.Reference()
+		req.DestinationDatacenter = &ref
+	}
+
+	res, err := methods.MoveDatastoreFile_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/folder.go

@@ -0,0 +1,227 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type Folder struct {
+	Common
+}
+
+func NewFolder(c *vim25.Client, ref types.ManagedObjectReference) *Folder {
+	return &Folder{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func NewRootFolder(c *vim25.Client) *Folder {
+	f := NewFolder(c, c.ServiceContent.RootFolder)
+	f.InventoryPath = "/"
+	return f
+}
+
+func (f Folder) Children(ctx context.Context) ([]Reference, error) {
+	var mf mo.Folder
+
+	err := f.Properties(ctx, f.Reference(), []string{"childEntity"}, &mf)
+	if err != nil {
+		return nil, err
+	}
+
+	var rs []Reference
+	for _, e := range mf.ChildEntity {
+		if r := NewReference(f.c, e); r != nil {
+			rs = append(rs, r)
+		}
+	}
+
+	return rs, nil
+}
+
+func (f Folder) CreateDatacenter(ctx context.Context, datacenter string) (*Datacenter, error) {
+	req := types.CreateDatacenter{
+		This: f.Reference(),
+		Name: datacenter,
+	}
+
+	res, err := methods.CreateDatacenter(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	// Response will be nil if this is an ESX host that does not belong to a vCenter
+	if res == nil {
+		return nil, nil
+	}
+
+	return NewDatacenter(f.c, res.Returnval), nil
+}
+
+func (f Folder) CreateCluster(ctx context.Context, cluster string, spec types.ClusterConfigSpecEx) (*ClusterComputeResource, error) {
+	req := types.CreateClusterEx{
+		This: f.Reference(),
+		Name: cluster,
+		Spec: spec,
+	}
+
+	res, err := methods.CreateClusterEx(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	// Response will be nil if this is an ESX host that does not belong to a vCenter
+	if res == nil {
+		return nil, nil
+	}
+
+	return NewClusterComputeResource(f.c, res.Returnval), nil
+}
+
+func (f Folder) CreateFolder(ctx context.Context, name string) (*Folder, error) {
+	req := types.CreateFolder{
+		This: f.Reference(),
+		Name: name,
+	}
+
+	res, err := methods.CreateFolder(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewFolder(f.c, res.Returnval), err
+}
+
+func (f Folder) CreateStoragePod(ctx context.Context, name string) (*StoragePod, error) {
+	req := types.CreateStoragePod{
+		This: f.Reference(),
+		Name: name,
+	}
+
+	res, err := methods.CreateStoragePod(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewStoragePod(f.c, res.Returnval), err
+}
+
+func (f Folder) AddStandaloneHost(ctx context.Context, spec types.HostConnectSpec, addConnected bool, license *string, compResSpec *types.BaseComputeResourceConfigSpec) (*Task, error) {
+	req := types.AddStandaloneHost_Task{
+		This:         f.Reference(),
+		Spec:         spec,
+		AddConnected: addConnected,
+	}
+
+	if license != nil {
+		req.License = *license
+	}
+
+	if compResSpec != nil {
+		req.CompResSpec = *compResSpec
+	}
+
+	res, err := methods.AddStandaloneHost_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}
+
+func (f Folder) CreateVM(ctx context.Context, config types.VirtualMachineConfigSpec, pool *ResourcePool, host *HostSystem) (*Task, error) {
+	req := types.CreateVM_Task{
+		This:   f.Reference(),
+		Config: config,
+		Pool:   pool.Reference(),
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	res, err := methods.CreateVM_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}
+
+func (f Folder) RegisterVM(ctx context.Context, path string, name string, asTemplate bool, pool *ResourcePool, host *HostSystem) (*Task, error) {
+	req := types.RegisterVM_Task{
+		This:       f.Reference(),
+		Path:       path,
+		AsTemplate: asTemplate,
+	}
+
+	if name != "" {
+		req.Name = name
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	if pool != nil {
+		ref := pool.Reference()
+		req.Pool = &ref
+	}
+
+	res, err := methods.RegisterVM_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}
+
+func (f Folder) CreateDVS(ctx context.Context, spec types.DVSCreateSpec) (*Task, error) {
+	req := types.CreateDVS_Task{
+		This: f.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.CreateDVS_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}
+
+func (f Folder) MoveInto(ctx context.Context, list []types.ManagedObjectReference) (*Task, error) {
+	req := types.MoveIntoFolder_Task{
+		This: f.Reference(),
+		List: list,
+	}
+
+	res, err := methods.MoveIntoFolder_Task(ctx, f.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(f.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/folder_test.go

@@ -0,0 +1,20 @@
+/*
+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 object
+
+// Folder should implement the Reference interface.
+var _ Reference = Folder{}

vendor/github.com/vmware/govmomi/object/history_collector.go

@@ -0,0 +1,72 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HistoryCollector struct {
+	Common
+}
+
+func NewHistoryCollector(c *vim25.Client, ref types.ManagedObjectReference) *HistoryCollector {
+	return &HistoryCollector{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (h HistoryCollector) Destroy(ctx context.Context) error {
+	req := types.DestroyCollector{
+		This: h.Reference(),
+	}
+
+	_, err := methods.DestroyCollector(ctx, h.c, &req)
+	return err
+}
+
+func (h HistoryCollector) Reset(ctx context.Context) error {
+	req := types.ResetCollector{
+		This: h.Reference(),
+	}
+
+	_, err := methods.ResetCollector(ctx, h.c, &req)
+	return err
+}
+
+func (h HistoryCollector) Rewind(ctx context.Context) error {
+	req := types.RewindCollector{
+		This: h.Reference(),
+	}
+
+	_, err := methods.RewindCollector(ctx, h.c, &req)
+	return err
+}
+
+func (h HistoryCollector) SetPageSize(ctx context.Context, maxCount int32) error {
+	req := types.SetCollectorPageSize{
+		This:     h.Reference(),
+		MaxCount: maxCount,
+	}
+
+	_, err := methods.SetCollectorPageSize(ctx, h.c, &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/host_account_manager.go

@@ -0,0 +1,65 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostAccountManager struct {
+	Common
+}
+
+func NewHostAccountManager(c *vim25.Client, ref types.ManagedObjectReference) *HostAccountManager {
+	return &HostAccountManager{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (m HostAccountManager) Create(ctx context.Context, user *types.HostAccountSpec) error {
+	req := types.CreateUser{
+		This: m.Reference(),
+		User: user,
+	}
+
+	_, err := methods.CreateUser(ctx, m.Client(), &req)
+	return err
+}
+
+func (m HostAccountManager) Update(ctx context.Context, user *types.HostAccountSpec) error {
+	req := types.UpdateUser{
+		This: m.Reference(),
+		User: user,
+	}
+
+	_, err := methods.UpdateUser(ctx, m.Client(), &req)
+	return err
+}
+
+func (m HostAccountManager) Remove(ctx context.Context, userName string) error {
+	req := types.RemoveUser{
+		This:     m.Reference(),
+		UserName: userName,
+	}
+
+	_, err := methods.RemoveUser(ctx, m.Client(), &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/host_certificate_info.go

@@ -0,0 +1,250 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"crypto/sha256"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/asn1"
+	"fmt"
+	"io"
+	"net/url"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// HostCertificateInfo provides helpers for types.HostCertificateManagerCertificateInfo
+type HostCertificateInfo struct {
+	types.HostCertificateManagerCertificateInfo
+
+	ThumbprintSHA1   string
+	ThumbprintSHA256 string
+
+	Err         error
+	Certificate *x509.Certificate `json:"-"`
+
+	subjectName *pkix.Name
+	issuerName  *pkix.Name
+}
+
+// FromCertificate converts x509.Certificate to HostCertificateInfo
+func (info *HostCertificateInfo) FromCertificate(cert *x509.Certificate) *HostCertificateInfo {
+	info.Certificate = cert
+	info.subjectName = &cert.Subject
+	info.issuerName = &cert.Issuer
+
+	info.Issuer = info.fromName(info.issuerName)
+	info.NotBefore = &cert.NotBefore
+	info.NotAfter = &cert.NotAfter
+	info.Subject = info.fromName(info.subjectName)
+
+	info.ThumbprintSHA1 = soap.ThumbprintSHA1(cert)
+
+	// SHA-256 for info purposes only, API fields all use SHA-1
+	sum := sha256.Sum256(cert.Raw)
+	hex := make([]string, len(sum))
+	for i, b := range sum {
+		hex[i] = fmt.Sprintf("%02X", b)
+	}
+	info.ThumbprintSHA256 = strings.Join(hex, ":")
+
+	if info.Status == "" {
+		info.Status = string(types.HostCertificateManagerCertificateInfoCertificateStatusUnknown)
+	}
+
+	return info
+}
+
+// FromURL connects to the given URL.Host via tls.Dial with the given tls.Config and populates the HostCertificateInfo
+// via tls.ConnectionState.  If the certificate was verified with the given tls.Config, the Err field will be nil.
+// Otherwise, Err will be set to the x509.UnknownAuthorityError or x509.HostnameError.
+// If tls.Dial returns an error of any other type, that error is returned.
+func (info *HostCertificateInfo) FromURL(u *url.URL, config *tls.Config) error {
+	addr := u.Host
+	if !(strings.LastIndex(addr, ":") > strings.LastIndex(addr, "]")) {
+		addr += ":443"
+	}
+
+	conn, err := tls.Dial("tcp", addr, config)
+	if err != nil {
+		switch err.(type) {
+		case x509.UnknownAuthorityError:
+		case x509.HostnameError:
+		default:
+			return err
+		}
+
+		info.Err = err
+
+		conn, err = tls.Dial("tcp", addr, &tls.Config{InsecureSkipVerify: true})
+		if err != nil {
+			return err
+		}
+	} else {
+		info.Status = string(types.HostCertificateManagerCertificateInfoCertificateStatusGood)
+	}
+
+	state := conn.ConnectionState()
+	_ = conn.Close()
+	info.FromCertificate(state.PeerCertificates[0])
+
+	return nil
+}
+
+var emailAddressOID = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 9, 1}
+
+func (info *HostCertificateInfo) fromName(name *pkix.Name) string {
+	var attrs []string
+
+	oids := map[string]string{
+		emailAddressOID.String(): "emailAddress",
+	}
+
+	for _, attr := range name.Names {
+		if key, ok := oids[attr.Type.String()]; ok {
+			attrs = append(attrs, fmt.Sprintf("%s=%s", key, attr.Value))
+		}
+	}
+
+	attrs = append(attrs, fmt.Sprintf("CN=%s", name.CommonName))
+
+	add := func(key string, vals []string) {
+		for _, val := range vals {
+			attrs = append(attrs, fmt.Sprintf("%s=%s", key, val))
+		}
+	}
+
+	elts := []struct {
+		key string
+		val []string
+	}{
+		{"OU", name.OrganizationalUnit},
+		{"O", name.Organization},
+		{"L", name.Locality},
+		{"ST", name.Province},
+		{"C", name.Country},
+	}
+
+	for _, elt := range elts {
+		add(elt.key, elt.val)
+	}
+
+	return strings.Join(attrs, ",")
+}
+
+func (info *HostCertificateInfo) toName(s string) *pkix.Name {
+	var name pkix.Name
+
+	for _, pair := range strings.Split(s, ",") {
+		attr := strings.SplitN(pair, "=", 2)
+		if len(attr) != 2 {
+			continue
+		}
+
+		v := attr[1]
+
+		switch strings.ToLower(attr[0]) {
+		case "cn":
+			name.CommonName = v
+		case "ou":
+			name.OrganizationalUnit = append(name.OrganizationalUnit, v)
+		case "o":
+			name.Organization = append(name.Organization, v)
+		case "l":
+			name.Locality = append(name.Locality, v)
+		case "st":
+			name.Province = append(name.Province, v)
+		case "c":
+			name.Country = append(name.Country, v)
+		case "emailaddress":
+			name.Names = append(name.Names, pkix.AttributeTypeAndValue{Type: emailAddressOID, Value: v})
+		}
+	}
+
+	return &name
+}
+
+// SubjectName parses Subject into a pkix.Name
+func (info *HostCertificateInfo) SubjectName() *pkix.Name {
+	if info.subjectName != nil {
+		return info.subjectName
+	}
+
+	return info.toName(info.Subject)
+}
+
+// IssuerName parses Issuer into a pkix.Name
+func (info *HostCertificateInfo) IssuerName() *pkix.Name {
+	if info.issuerName != nil {
+		return info.issuerName
+	}
+
+	return info.toName(info.Issuer)
+}
+
+// Write outputs info similar to the Chrome Certificate Viewer.
+func (info *HostCertificateInfo) Write(w io.Writer) error {
+	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
+
+	s := func(val string) string {
+		if val != "" {
+			return val
+		}
+		return "<Not Part Of Certificate>"
+	}
+
+	ss := func(val []string) string {
+		return s(strings.Join(val, ","))
+	}
+
+	name := func(n *pkix.Name) {
+		fmt.Fprintf(tw, "  Common Name (CN):\t%s\n", s(n.CommonName))
+		fmt.Fprintf(tw, "  Organization (O):\t%s\n", ss(n.Organization))
+		fmt.Fprintf(tw, "  Organizational Unit (OU):\t%s\n", ss(n.OrganizationalUnit))
+	}
+
+	status := info.Status
+	if info.Err != nil {
+		status = fmt.Sprintf("ERROR %s", info.Err)
+	}
+	fmt.Fprintf(tw, "Certificate Status:\t%s\n", status)
+
+	fmt.Fprintln(tw, "Issued To:\t")
+	name(info.SubjectName())
+
+	fmt.Fprintln(tw, "Issued By:\t")
+	name(info.IssuerName())
+
+	fmt.Fprintln(tw, "Validity Period:\t")
+	fmt.Fprintf(tw, "  Issued On:\t%s\n", info.NotBefore)
+	fmt.Fprintf(tw, "  Expires On:\t%s\n", info.NotAfter)
+
+	if info.ThumbprintSHA1 != "" {
+		fmt.Fprintln(tw, "Thumbprints:\t")
+		if info.ThumbprintSHA256 != "" {
+			fmt.Fprintf(tw, "  SHA-256 Thumbprint:\t%s\n", info.ThumbprintSHA256)
+		}
+		fmt.Fprintf(tw, "  SHA-1 Thumbprint:\t%s\n", info.ThumbprintSHA1)
+	}
+
+	return tw.Flush()
+}

vendor/github.com/vmware/govmomi/object/host_certificate_info_test.go

@@ -0,0 +1,30 @@
+/*
+Copyright (c) 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 object
+
+import "testing"
+
+func TestHostCertificateManagerCertificateInfo(t *testing.T) {
+	subject := "emailAddress=vmca@vmware.com,CN=w2-xlr8-autoroot-esx004.eng.vmware.com,OU=VMware Engineering,O=VMware,L=Palo Alto,ST=California,C=US"
+
+	var info HostCertificateInfo
+	name := info.toName(subject)
+	s := info.fromName(name)
+	if subject != s {
+		t.Errorf("%s != %s", s, subject)
+	}
+}

vendor/github.com/vmware/govmomi/object/host_certificate_manager.go

@@ -0,0 +1,162 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// HostCertificateManager provides helper methods around the HostSystem.ConfigManager.CertificateManager
+type HostCertificateManager struct {
+	Common
+	Host *HostSystem
+}
+
+// NewHostCertificateManager creates a new HostCertificateManager helper
+func NewHostCertificateManager(c *vim25.Client, ref types.ManagedObjectReference, host types.ManagedObjectReference) *HostCertificateManager {
+	return &HostCertificateManager{
+		Common: NewCommon(c, ref),
+		Host:   NewHostSystem(c, host),
+	}
+}
+
+// CertificateInfo wraps the host CertificateManager certificateInfo property with the HostCertificateInfo helper.
+// The ThumbprintSHA1 field is set to HostSystem.Summary.Config.SslThumbprint if the host system is managed by a vCenter.
+func (m HostCertificateManager) CertificateInfo(ctx context.Context) (*HostCertificateInfo, error) {
+	var hs mo.HostSystem
+	var cm mo.HostCertificateManager
+
+	pc := property.DefaultCollector(m.Client())
+
+	err := pc.RetrieveOne(ctx, m.Reference(), []string{"certificateInfo"}, &cm)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = pc.RetrieveOne(ctx, m.Host.Reference(), []string{"summary.config.sslThumbprint"}, &hs)
+
+	return &HostCertificateInfo{
+		HostCertificateManagerCertificateInfo: cm.CertificateInfo,
+		ThumbprintSHA1:                        hs.Summary.Config.SslThumbprint,
+	}, nil
+}
+
+// GenerateCertificateSigningRequest requests the host system to generate a certificate-signing request (CSR) for itself.
+// The CSR is then typically provided to a Certificate Authority to sign and issue the SSL certificate for the host system.
+// Use InstallServerCertificate to import this certificate.
+func (m HostCertificateManager) GenerateCertificateSigningRequest(ctx context.Context, useIPAddressAsCommonName bool) (string, error) {
+	req := types.GenerateCertificateSigningRequest{
+		This: m.Reference(),
+		UseIpAddressAsCommonName: useIPAddressAsCommonName,
+	}
+
+	res, err := methods.GenerateCertificateSigningRequest(ctx, m.Client(), &req)
+	if err != nil {
+		return "", err
+	}
+
+	return res.Returnval, nil
+}
+
+// GenerateCertificateSigningRequestByDn requests the host system to generate a certificate-signing request (CSR) for itself.
+// Alternative version similar to GenerateCertificateSigningRequest but takes a Distinguished Name (DN) as a parameter.
+func (m HostCertificateManager) GenerateCertificateSigningRequestByDn(ctx context.Context, distinguishedName string) (string, error) {
+	req := types.GenerateCertificateSigningRequestByDn{
+		This:              m.Reference(),
+		DistinguishedName: distinguishedName,
+	}
+
+	res, err := methods.GenerateCertificateSigningRequestByDn(ctx, m.Client(), &req)
+	if err != nil {
+		return "", err
+	}
+
+	return res.Returnval, nil
+}
+
+// InstallServerCertificate imports the given SSL certificate to the host system.
+func (m HostCertificateManager) InstallServerCertificate(ctx context.Context, cert string) error {
+	req := types.InstallServerCertificate{
+		This: m.Reference(),
+		Cert: cert,
+	}
+
+	_, err := methods.InstallServerCertificate(ctx, m.Client(), &req)
+	if err != nil {
+		return err
+	}
+
+	// NotifyAffectedService is internal, not exposing as we don't have a use case other than with InstallServerCertificate
+	// Without this call, hostd needs to be restarted to use the updated certificate
+	// Note: using Refresh as it has the same struct/signature, we just need to use different xml name tags
+	body := struct {
+		Req *types.Refresh         `xml:"urn:vim25 NotifyAffectedServices,omitempty"`
+		Res *types.RefreshResponse `xml:"urn:vim25 NotifyAffectedServicesResponse,omitempty"`
+		methods.RefreshBody
+	}{
+		Req: &types.Refresh{This: m.Reference()},
+	}
+
+	return m.Client().RoundTrip(ctx, &body, &body)
+}
+
+// ListCACertificateRevocationLists returns the SSL CRLs of Certificate Authorities that are trusted by the host system.
+func (m HostCertificateManager) ListCACertificateRevocationLists(ctx context.Context) ([]string, error) {
+	req := types.ListCACertificateRevocationLists{
+		This: m.Reference(),
+	}
+
+	res, err := methods.ListCACertificateRevocationLists(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+// ListCACertificates returns the SSL certificates of Certificate Authorities that are trusted by the host system.
+func (m HostCertificateManager) ListCACertificates(ctx context.Context) ([]string, error) {
+	req := types.ListCACertificates{
+		This: m.Reference(),
+	}
+
+	res, err := methods.ListCACertificates(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+// ReplaceCACertificatesAndCRLs replaces the trusted CA certificates and CRL used by the host system.
+// These determine whether the server can verify the identity of an external entity.
+func (m HostCertificateManager) ReplaceCACertificatesAndCRLs(ctx context.Context, caCert []string, caCrl []string) error {
+	req := types.ReplaceCACertificatesAndCRLs{
+		This:   m.Reference(),
+		CaCert: caCert,
+		CaCrl:  caCrl,
+	}
+
+	_, err := methods.ReplaceCACertificatesAndCRLs(ctx, m.Client(), &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/host_config_manager.go

@@ -0,0 +1,196 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostConfigManager struct {
+	Common
+}
+
+func NewHostConfigManager(c *vim25.Client, ref types.ManagedObjectReference) *HostConfigManager {
+	return &HostConfigManager{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (m HostConfigManager) DatastoreSystem(ctx context.Context) (*HostDatastoreSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.datastoreSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostDatastoreSystem(m.c, *h.ConfigManager.DatastoreSystem), nil
+}
+
+func (m HostConfigManager) NetworkSystem(ctx context.Context) (*HostNetworkSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.networkSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostNetworkSystem(m.c, *h.ConfigManager.NetworkSystem), nil
+}
+
+func (m HostConfigManager) FirewallSystem(ctx context.Context) (*HostFirewallSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.firewallSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostFirewallSystem(m.c, *h.ConfigManager.FirewallSystem), nil
+}
+
+func (m HostConfigManager) StorageSystem(ctx context.Context) (*HostStorageSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.storageSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostStorageSystem(m.c, *h.ConfigManager.StorageSystem), nil
+}
+
+func (m HostConfigManager) VirtualNicManager(ctx context.Context) (*HostVirtualNicManager, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.virtualNicManager"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostVirtualNicManager(m.c, *h.ConfigManager.VirtualNicManager, m.Reference()), nil
+}
+
+func (m HostConfigManager) VsanSystem(ctx context.Context) (*HostVsanSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.vsanSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	// Added in 5.5
+	if h.ConfigManager.VsanSystem == nil {
+		return nil, ErrNotSupported
+	}
+
+	return NewHostVsanSystem(m.c, *h.ConfigManager.VsanSystem), nil
+}
+
+func (m HostConfigManager) VsanInternalSystem(ctx context.Context) (*HostVsanInternalSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.vsanInternalSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	// Added in 5.5
+	if h.ConfigManager.VsanInternalSystem == nil {
+		return nil, ErrNotSupported
+	}
+
+	return NewHostVsanInternalSystem(m.c, *h.ConfigManager.VsanInternalSystem), nil
+}
+
+func (m HostConfigManager) AccountManager(ctx context.Context) (*HostAccountManager, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.accountManager"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	ref := h.ConfigManager.AccountManager // Added in 6.0
+	if ref == nil {
+		// Versions < 5.5 can use the ServiceContent ref,
+		// but we can only use it when connected directly to ESX.
+		c := m.Client()
+		if !c.IsVC() {
+			ref = c.ServiceContent.AccountManager
+		}
+
+		if ref == nil {
+			return nil, ErrNotSupported
+		}
+	}
+
+	return NewHostAccountManager(m.c, *ref), nil
+}
+
+func (m HostConfigManager) OptionManager(ctx context.Context) (*OptionManager, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.advancedOption"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewOptionManager(m.c, *h.ConfigManager.AdvancedOption), nil
+}
+
+func (m HostConfigManager) ServiceSystem(ctx context.Context) (*HostServiceSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.serviceSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostServiceSystem(m.c, *h.ConfigManager.ServiceSystem), nil
+}
+
+func (m HostConfigManager) CertificateManager(ctx context.Context) (*HostCertificateManager, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.certificateManager"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	// Added in 6.0
+	if h.ConfigManager.CertificateManager == nil {
+		return nil, ErrNotSupported
+	}
+
+	return NewHostCertificateManager(m.c, *h.ConfigManager.CertificateManager, m.Reference()), nil
+}
+
+func (m HostConfigManager) DateTimeSystem(ctx context.Context) (*HostDateTimeSystem, error) {
+	var h mo.HostSystem
+
+	err := m.Properties(ctx, m.Reference(), []string{"configManager.dateTimeSystem"}, &h)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewHostDateTimeSystem(m.c, *h.ConfigManager.DateTimeSystem), nil
+}

vendor/github.com/vmware/govmomi/object/host_datastore_browser.go

@@ -0,0 +1,65 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostDatastoreBrowser struct {
+	Common
+}
+
+func NewHostDatastoreBrowser(c *vim25.Client, ref types.ManagedObjectReference) *HostDatastoreBrowser {
+	return &HostDatastoreBrowser{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (b HostDatastoreBrowser) SearchDatastore(ctx context.Context, datastorePath string, searchSpec *types.HostDatastoreBrowserSearchSpec) (*Task, error) {
+	req := types.SearchDatastore_Task{
+		This:          b.Reference(),
+		DatastorePath: datastorePath,
+		SearchSpec:    searchSpec,
+	}
+
+	res, err := methods.SearchDatastore_Task(ctx, b.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(b.c, res.Returnval), nil
+}
+
+func (b HostDatastoreBrowser) SearchDatastoreSubFolders(ctx context.Context, datastorePath string, searchSpec *types.HostDatastoreBrowserSearchSpec) (*Task, error) {
+	req := types.SearchDatastoreSubFolders_Task{
+		This:          b.Reference(),
+		DatastorePath: datastorePath,
+		SearchSpec:    searchSpec,
+	}
+
+	res, err := methods.SearchDatastoreSubFolders_Task(ctx, b.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(b.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/host_datastore_system.go

@@ -0,0 +1,119 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostDatastoreSystem struct {
+	Common
+}
+
+func NewHostDatastoreSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostDatastoreSystem {
+	return &HostDatastoreSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s HostDatastoreSystem) CreateLocalDatastore(ctx context.Context, name string, path string) (*Datastore, error) {
+	req := types.CreateLocalDatastore{
+		This: s.Reference(),
+		Name: name,
+		Path: path,
+	}
+
+	res, err := methods.CreateLocalDatastore(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewDatastore(s.Client(), res.Returnval), nil
+}
+
+func (s HostDatastoreSystem) CreateNasDatastore(ctx context.Context, spec types.HostNasVolumeSpec) (*Datastore, error) {
+	req := types.CreateNasDatastore{
+		This: s.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.CreateNasDatastore(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewDatastore(s.Client(), res.Returnval), nil
+}
+
+func (s HostDatastoreSystem) CreateVmfsDatastore(ctx context.Context, spec types.VmfsDatastoreCreateSpec) (*Datastore, error) {
+	req := types.CreateVmfsDatastore{
+		This: s.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.CreateVmfsDatastore(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewDatastore(s.Client(), res.Returnval), nil
+}
+
+func (s HostDatastoreSystem) Remove(ctx context.Context, ds *Datastore) error {
+	req := types.RemoveDatastore{
+		This:      s.Reference(),
+		Datastore: ds.Reference(),
+	}
+
+	_, err := methods.RemoveDatastore(ctx, s.Client(), &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s HostDatastoreSystem) QueryAvailableDisksForVmfs(ctx context.Context) ([]types.HostScsiDisk, error) {
+	req := types.QueryAvailableDisksForVmfs{
+		This: s.Reference(),
+	}
+
+	res, err := methods.QueryAvailableDisksForVmfs(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (s HostDatastoreSystem) QueryVmfsDatastoreCreateOptions(ctx context.Context, devicePath string) ([]types.VmfsDatastoreOption, error) {
+	req := types.QueryVmfsDatastoreCreateOptions{
+		This:       s.Reference(),
+		DevicePath: devicePath,
+	}
+
+	res, err := methods.QueryVmfsDatastoreCreateOptions(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/host_date_time_system.go

@@ -0,0 +1,69 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+	"time"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostDateTimeSystem struct {
+	Common
+}
+
+func NewHostDateTimeSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostDateTimeSystem {
+	return &HostDateTimeSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s HostDateTimeSystem) UpdateConfig(ctx context.Context, config types.HostDateTimeConfig) error {
+	req := types.UpdateDateTimeConfig{
+		This:   s.Reference(),
+		Config: config,
+	}
+
+	_, err := methods.UpdateDateTimeConfig(ctx, s.c, &req)
+	return err
+}
+
+func (s HostDateTimeSystem) Update(ctx context.Context, date time.Time) error {
+	req := types.UpdateDateTime{
+		This:     s.Reference(),
+		DateTime: date,
+	}
+
+	_, err := methods.UpdateDateTime(ctx, s.c, &req)
+	return err
+}
+
+func (s HostDateTimeSystem) Query(ctx context.Context) (*time.Time, error) {
+	req := types.QueryDateTime{
+		This: s.Reference(),
+	}
+
+	res, err := methods.QueryDateTime(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/host_firewall_system.go

@@ -0,0 +1,181 @@
+/*
+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 object
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostFirewallSystem struct {
+	Common
+}
+
+func NewHostFirewallSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostFirewallSystem {
+	return &HostFirewallSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s HostFirewallSystem) DisableRuleset(ctx context.Context, id string) error {
+	req := types.DisableRuleset{
+		This: s.Reference(),
+		Id:   id,
+	}
+
+	_, err := methods.DisableRuleset(ctx, s.c, &req)
+	return err
+}
+
+func (s HostFirewallSystem) EnableRuleset(ctx context.Context, id string) error {
+	req := types.EnableRuleset{
+		This: s.Reference(),
+		Id:   id,
+	}
+
+	_, err := methods.EnableRuleset(ctx, s.c, &req)
+	return err
+}
+
+func (s HostFirewallSystem) Refresh(ctx context.Context) error {
+	req := types.RefreshFirewall{
+		This: s.Reference(),
+	}
+
+	_, err := methods.RefreshFirewall(ctx, s.c, &req)
+	return err
+}
+
+func (s HostFirewallSystem) Info(ctx context.Context) (*types.HostFirewallInfo, error) {
+	var fs mo.HostFirewallSystem
+
+	err := s.Properties(ctx, s.Reference(), []string{"firewallInfo"}, &fs)
+	if err != nil {
+		return nil, err
+	}
+
+	return fs.FirewallInfo, nil
+}
+
+// HostFirewallRulesetList provides helpers for a slice of types.HostFirewallRuleset
+type HostFirewallRulesetList []types.HostFirewallRuleset
+
+// ByRule returns a HostFirewallRulesetList where Direction, PortType and Protocol are equal and Port is within range
+func (l HostFirewallRulesetList) ByRule(rule types.HostFirewallRule) HostFirewallRulesetList {
+	var matches HostFirewallRulesetList
+
+	for _, rs := range l {
+		for _, r := range rs.Rule {
+			if r.PortType != rule.PortType ||
+				r.Protocol != rule.Protocol ||
+				r.Direction != rule.Direction {
+				continue
+			}
+
+			if r.EndPort == 0 && rule.Port == r.Port ||
+				rule.Port >= r.Port && rule.Port <= r.EndPort {
+				matches = append(matches, rs)
+				break
+			}
+		}
+	}
+
+	return matches
+}
+
+// EnabledByRule returns a HostFirewallRulesetList with Match(rule) applied and filtered via Enabled()
+// if enabled param is true, otherwise filtered via Disabled().
+// An error is returned if the resulting list is empty.
+func (l HostFirewallRulesetList) EnabledByRule(rule types.HostFirewallRule, enabled bool) (HostFirewallRulesetList, error) {
+	var matched, skipped HostFirewallRulesetList
+	var matchedKind, skippedKind string
+
+	l = l.ByRule(rule)
+
+	if enabled {
+		matched = l.Enabled()
+		matchedKind = "enabled"
+
+		skipped = l.Disabled()
+		skippedKind = "disabled"
+	} else {
+		matched = l.Disabled()
+		matchedKind = "disabled"
+
+		skipped = l.Enabled()
+		skippedKind = "enabled"
+	}
+
+	if len(matched) == 0 {
+		msg := fmt.Sprintf("%d %s firewall rulesets match %s %s %s %d, %d %s rulesets match",
+			len(matched), matchedKind,
+			rule.Direction, rule.Protocol, rule.PortType, rule.Port,
+			len(skipped), skippedKind)
+
+		if len(skipped) != 0 {
+			msg += fmt.Sprintf(": %s", strings.Join(skipped.Keys(), ", "))
+		}
+
+		return nil, errors.New(msg)
+	}
+
+	return matched, nil
+}
+
+// Enabled returns a HostFirewallRulesetList with enabled rules
+func (l HostFirewallRulesetList) Enabled() HostFirewallRulesetList {
+	var matches HostFirewallRulesetList
+
+	for _, rs := range l {
+		if rs.Enabled {
+			matches = append(matches, rs)
+		}
+	}
+
+	return matches
+}
+
+// Disabled returns a HostFirewallRulesetList with disabled rules
+func (l HostFirewallRulesetList) Disabled() HostFirewallRulesetList {
+	var matches HostFirewallRulesetList
+
+	for _, rs := range l {
+		if !rs.Enabled {
+			matches = append(matches, rs)
+		}
+	}
+
+	return matches
+}
+
+// Keys returns the HostFirewallRuleset.Key for each ruleset in the list
+func (l HostFirewallRulesetList) Keys() []string {
+	var keys []string
+
+	for _, rs := range l {
+		keys = append(keys, rs.Key)
+	}
+
+	return keys
+}

vendor/github.com/vmware/govmomi/object/host_network_system.go

@@ -0,0 +1,358 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostNetworkSystem struct {
+	Common
+}
+
+func NewHostNetworkSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostNetworkSystem {
+	return &HostNetworkSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+// AddPortGroup wraps methods.AddPortGroup
+func (o HostNetworkSystem) AddPortGroup(ctx context.Context, portgrp types.HostPortGroupSpec) error {
+	req := types.AddPortGroup{
+		This:    o.Reference(),
+		Portgrp: portgrp,
+	}
+
+	_, err := methods.AddPortGroup(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// AddServiceConsoleVirtualNic wraps methods.AddServiceConsoleVirtualNic
+func (o HostNetworkSystem) AddServiceConsoleVirtualNic(ctx context.Context, portgroup string, nic types.HostVirtualNicSpec) (string, error) {
+	req := types.AddServiceConsoleVirtualNic{
+		This:      o.Reference(),
+		Portgroup: portgroup,
+		Nic:       nic,
+	}
+
+	res, err := methods.AddServiceConsoleVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return "", err
+	}
+
+	return res.Returnval, nil
+}
+
+// AddVirtualNic wraps methods.AddVirtualNic
+func (o HostNetworkSystem) AddVirtualNic(ctx context.Context, portgroup string, nic types.HostVirtualNicSpec) (string, error) {
+	req := types.AddVirtualNic{
+		This:      o.Reference(),
+		Portgroup: portgroup,
+		Nic:       nic,
+	}
+
+	res, err := methods.AddVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return "", err
+	}
+
+	return res.Returnval, nil
+}
+
+// AddVirtualSwitch wraps methods.AddVirtualSwitch
+func (o HostNetworkSystem) AddVirtualSwitch(ctx context.Context, vswitchName string, spec *types.HostVirtualSwitchSpec) error {
+	req := types.AddVirtualSwitch{
+		This:        o.Reference(),
+		VswitchName: vswitchName,
+		Spec:        spec,
+	}
+
+	_, err := methods.AddVirtualSwitch(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// QueryNetworkHint wraps methods.QueryNetworkHint
+func (o HostNetworkSystem) QueryNetworkHint(ctx context.Context, device []string) error {
+	req := types.QueryNetworkHint{
+		This:   o.Reference(),
+		Device: device,
+	}
+
+	_, err := methods.QueryNetworkHint(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RefreshNetworkSystem wraps methods.RefreshNetworkSystem
+func (o HostNetworkSystem) RefreshNetworkSystem(ctx context.Context) error {
+	req := types.RefreshNetworkSystem{
+		This: o.Reference(),
+	}
+
+	_, err := methods.RefreshNetworkSystem(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RemovePortGroup wraps methods.RemovePortGroup
+func (o HostNetworkSystem) RemovePortGroup(ctx context.Context, pgName string) error {
+	req := types.RemovePortGroup{
+		This:   o.Reference(),
+		PgName: pgName,
+	}
+
+	_, err := methods.RemovePortGroup(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RemoveServiceConsoleVirtualNic wraps methods.RemoveServiceConsoleVirtualNic
+func (o HostNetworkSystem) RemoveServiceConsoleVirtualNic(ctx context.Context, device string) error {
+	req := types.RemoveServiceConsoleVirtualNic{
+		This:   o.Reference(),
+		Device: device,
+	}
+
+	_, err := methods.RemoveServiceConsoleVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RemoveVirtualNic wraps methods.RemoveVirtualNic
+func (o HostNetworkSystem) RemoveVirtualNic(ctx context.Context, device string) error {
+	req := types.RemoveVirtualNic{
+		This:   o.Reference(),
+		Device: device,
+	}
+
+	_, err := methods.RemoveVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RemoveVirtualSwitch wraps methods.RemoveVirtualSwitch
+func (o HostNetworkSystem) RemoveVirtualSwitch(ctx context.Context, vswitchName string) error {
+	req := types.RemoveVirtualSwitch{
+		This:        o.Reference(),
+		VswitchName: vswitchName,
+	}
+
+	_, err := methods.RemoveVirtualSwitch(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RestartServiceConsoleVirtualNic wraps methods.RestartServiceConsoleVirtualNic
+func (o HostNetworkSystem) RestartServiceConsoleVirtualNic(ctx context.Context, device string) error {
+	req := types.RestartServiceConsoleVirtualNic{
+		This:   o.Reference(),
+		Device: device,
+	}
+
+	_, err := methods.RestartServiceConsoleVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateConsoleIpRouteConfig wraps methods.UpdateConsoleIpRouteConfig
+func (o HostNetworkSystem) UpdateConsoleIpRouteConfig(ctx context.Context, config types.BaseHostIpRouteConfig) error {
+	req := types.UpdateConsoleIpRouteConfig{
+		This:   o.Reference(),
+		Config: config,
+	}
+
+	_, err := methods.UpdateConsoleIpRouteConfig(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateDnsConfig wraps methods.UpdateDnsConfig
+func (o HostNetworkSystem) UpdateDnsConfig(ctx context.Context, config types.BaseHostDnsConfig) error {
+	req := types.UpdateDnsConfig{
+		This:   o.Reference(),
+		Config: config,
+	}
+
+	_, err := methods.UpdateDnsConfig(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateIpRouteConfig wraps methods.UpdateIpRouteConfig
+func (o HostNetworkSystem) UpdateIpRouteConfig(ctx context.Context, config types.BaseHostIpRouteConfig) error {
+	req := types.UpdateIpRouteConfig{
+		This:   o.Reference(),
+		Config: config,
+	}
+
+	_, err := methods.UpdateIpRouteConfig(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateIpRouteTableConfig wraps methods.UpdateIpRouteTableConfig
+func (o HostNetworkSystem) UpdateIpRouteTableConfig(ctx context.Context, config types.HostIpRouteTableConfig) error {
+	req := types.UpdateIpRouteTableConfig{
+		This:   o.Reference(),
+		Config: config,
+	}
+
+	_, err := methods.UpdateIpRouteTableConfig(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateNetworkConfig wraps methods.UpdateNetworkConfig
+func (o HostNetworkSystem) UpdateNetworkConfig(ctx context.Context, config types.HostNetworkConfig, changeMode string) (*types.HostNetworkConfigResult, error) {
+	req := types.UpdateNetworkConfig{
+		This:       o.Reference(),
+		Config:     config,
+		ChangeMode: changeMode,
+	}
+
+	res, err := methods.UpdateNetworkConfig(ctx, o.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+// UpdatePhysicalNicLinkSpeed wraps methods.UpdatePhysicalNicLinkSpeed
+func (o HostNetworkSystem) UpdatePhysicalNicLinkSpeed(ctx context.Context, device string, linkSpeed *types.PhysicalNicLinkInfo) error {
+	req := types.UpdatePhysicalNicLinkSpeed{
+		This:      o.Reference(),
+		Device:    device,
+		LinkSpeed: linkSpeed,
+	}
+
+	_, err := methods.UpdatePhysicalNicLinkSpeed(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdatePortGroup wraps methods.UpdatePortGroup
+func (o HostNetworkSystem) UpdatePortGroup(ctx context.Context, pgName string, portgrp types.HostPortGroupSpec) error {
+	req := types.UpdatePortGroup{
+		This:    o.Reference(),
+		PgName:  pgName,
+		Portgrp: portgrp,
+	}
+
+	_, err := methods.UpdatePortGroup(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateServiceConsoleVirtualNic wraps methods.UpdateServiceConsoleVirtualNic
+func (o HostNetworkSystem) UpdateServiceConsoleVirtualNic(ctx context.Context, device string, nic types.HostVirtualNicSpec) error {
+	req := types.UpdateServiceConsoleVirtualNic{
+		This:   o.Reference(),
+		Device: device,
+		Nic:    nic,
+	}
+
+	_, err := methods.UpdateServiceConsoleVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateVirtualNic wraps methods.UpdateVirtualNic
+func (o HostNetworkSystem) UpdateVirtualNic(ctx context.Context, device string, nic types.HostVirtualNicSpec) error {
+	req := types.UpdateVirtualNic{
+		This:   o.Reference(),
+		Device: device,
+		Nic:    nic,
+	}
+
+	_, err := methods.UpdateVirtualNic(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// UpdateVirtualSwitch wraps methods.UpdateVirtualSwitch
+func (o HostNetworkSystem) UpdateVirtualSwitch(ctx context.Context, vswitchName string, spec types.HostVirtualSwitchSpec) error {
+	req := types.UpdateVirtualSwitch{
+		This:        o.Reference(),
+		VswitchName: vswitchName,
+		Spec:        spec,
+	}
+
+	_, err := methods.UpdateVirtualSwitch(ctx, o.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/object/host_service_system.go

@@ -0,0 +1,88 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostServiceSystem struct {
+	Common
+}
+
+func NewHostServiceSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostServiceSystem {
+	return &HostServiceSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s HostServiceSystem) Service(ctx context.Context) ([]types.HostService, error) {
+	var ss mo.HostServiceSystem
+
+	err := s.Properties(ctx, s.Reference(), []string{"serviceInfo.service"}, &ss)
+	if err != nil {
+		return nil, err
+	}
+
+	return ss.ServiceInfo.Service, nil
+}
+
+func (s HostServiceSystem) Start(ctx context.Context, id string) error {
+	req := types.StartService{
+		This: s.Reference(),
+		Id:   id,
+	}
+
+	_, err := methods.StartService(ctx, s.Client(), &req)
+	return err
+}
+
+func (s HostServiceSystem) Stop(ctx context.Context, id string) error {
+	req := types.StopService{
+		This: s.Reference(),
+		Id:   id,
+	}
+
+	_, err := methods.StopService(ctx, s.Client(), &req)
+	return err
+}
+
+func (s HostServiceSystem) Restart(ctx context.Context, id string) error {
+	req := types.RestartService{
+		This: s.Reference(),
+		Id:   id,
+	}
+
+	_, err := methods.RestartService(ctx, s.Client(), &req)
+	return err
+}
+
+func (s HostServiceSystem) UpdatePolicy(ctx context.Context, id string, policy string) error {
+	req := types.UpdateServicePolicy{
+		This:   s.Reference(),
+		Id:     id,
+		Policy: policy,
+	}
+
+	_, err := methods.UpdateServicePolicy(ctx, s.Client(), &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/host_storage_system.go

@@ -0,0 +1,174 @@
+/*
+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 object
+
+import (
+	"context"
+	"errors"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostStorageSystem struct {
+	Common
+}
+
+func NewHostStorageSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostStorageSystem {
+	return &HostStorageSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s HostStorageSystem) RetrieveDiskPartitionInfo(ctx context.Context, devicePath string) (*types.HostDiskPartitionInfo, error) {
+	req := types.RetrieveDiskPartitionInfo{
+		This:       s.Reference(),
+		DevicePath: []string{devicePath},
+	}
+
+	res, err := methods.RetrieveDiskPartitionInfo(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil || len(res.Returnval) == 0 {
+		return nil, errors.New("no partition info")
+	}
+
+	return &res.Returnval[0], nil
+}
+
+func (s HostStorageSystem) ComputeDiskPartitionInfo(ctx context.Context, devicePath string, layout types.HostDiskPartitionLayout) (*types.HostDiskPartitionInfo, error) {
+	req := types.ComputeDiskPartitionInfo{
+		This:       s.Reference(),
+		DevicePath: devicePath,
+		Layout:     layout,
+	}
+
+	res, err := methods.ComputeDiskPartitionInfo(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (s HostStorageSystem) UpdateDiskPartitionInfo(ctx context.Context, devicePath string, spec types.HostDiskPartitionSpec) error {
+	req := types.UpdateDiskPartitions{
+		This:       s.Reference(),
+		DevicePath: devicePath,
+		Spec:       spec,
+	}
+
+	_, err := methods.UpdateDiskPartitions(ctx, s.c, &req)
+	return err
+}
+
+func (s HostStorageSystem) RescanAllHba(ctx context.Context) error {
+	req := types.RescanAllHba{
+		This: s.Reference(),
+	}
+
+	_, err := methods.RescanAllHba(ctx, s.c, &req)
+	return err
+}
+
+func (s HostStorageSystem) Refresh(ctx context.Context) error {
+	req := types.RefreshStorageSystem{
+		This: s.Reference(),
+	}
+
+	_, err := methods.RefreshStorageSystem(ctx, s.c, &req)
+	return err
+}
+
+func (s HostStorageSystem) RescanVmfs(ctx context.Context) error {
+	req := types.RescanVmfs{
+		This: s.Reference(),
+	}
+
+	_, err := methods.RescanVmfs(ctx, s.c, &req)
+	return err
+}
+
+func (s HostStorageSystem) MarkAsSsd(ctx context.Context, uuid string) (*Task, error) {
+	req := types.MarkAsSsd_Task{
+		This:         s.Reference(),
+		ScsiDiskUuid: uuid,
+	}
+
+	res, err := methods.MarkAsSsd_Task(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.c, res.Returnval), nil
+}
+
+func (s HostStorageSystem) MarkAsNonSsd(ctx context.Context, uuid string) (*Task, error) {
+	req := types.MarkAsNonSsd_Task{
+		This:         s.Reference(),
+		ScsiDiskUuid: uuid,
+	}
+
+	res, err := methods.MarkAsNonSsd_Task(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.c, res.Returnval), nil
+}
+
+func (s HostStorageSystem) MarkAsLocal(ctx context.Context, uuid string) (*Task, error) {
+	req := types.MarkAsLocal_Task{
+		This:         s.Reference(),
+		ScsiDiskUuid: uuid,
+	}
+
+	res, err := methods.MarkAsLocal_Task(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.c, res.Returnval), nil
+}
+
+func (s HostStorageSystem) MarkAsNonLocal(ctx context.Context, uuid string) (*Task, error) {
+	req := types.MarkAsNonLocal_Task{
+		This:         s.Reference(),
+		ScsiDiskUuid: uuid,
+	}
+
+	res, err := methods.MarkAsNonLocal_Task(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.c, res.Returnval), nil
+}
+
+func (s HostStorageSystem) AttachScsiLun(ctx context.Context, uuid string) error {
+	req := types.AttachScsiLun{
+		This:    s.Reference(),
+		LunUuid: uuid,
+	}
+
+	_, err := methods.AttachScsiLun(ctx, s.c, &req)
+
+	return err
+}

vendor/github.com/vmware/govmomi/object/host_system.go

@@ -0,0 +1,153 @@
+/*
+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 object
+
+import (
+	"context"
+	"fmt"
+	"net"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostSystem struct {
+	Common
+}
+
+func NewHostSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostSystem {
+	return &HostSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (h HostSystem) ConfigManager() *HostConfigManager {
+	return NewHostConfigManager(h.c, h.Reference())
+}
+
+func (h HostSystem) ResourcePool(ctx context.Context) (*ResourcePool, error) {
+	var mh mo.HostSystem
+
+	err := h.Properties(ctx, h.Reference(), []string{"parent"}, &mh)
+	if err != nil {
+		return nil, err
+	}
+
+	var mcr *mo.ComputeResource
+	var parent interface{}
+
+	switch mh.Parent.Type {
+	case "ComputeResource":
+		mcr = new(mo.ComputeResource)
+		parent = mcr
+	case "ClusterComputeResource":
+		mcc := new(mo.ClusterComputeResource)
+		mcr = &mcc.ComputeResource
+		parent = mcc
+	default:
+		return nil, fmt.Errorf("unknown host parent type: %s", mh.Parent.Type)
+	}
+
+	err = h.Properties(ctx, *mh.Parent, []string{"resourcePool"}, parent)
+	if err != nil {
+		return nil, err
+	}
+
+	pool := NewResourcePool(h.c, *mcr.ResourcePool)
+	return pool, nil
+}
+
+func (h HostSystem) ManagementIPs(ctx context.Context) ([]net.IP, error) {
+	var mh mo.HostSystem
+
+	err := h.Properties(ctx, h.Reference(), []string{"config.virtualNicManagerInfo.netConfig"}, &mh)
+	if err != nil {
+		return nil, err
+	}
+
+	var ips []net.IP
+	for _, nc := range mh.Config.VirtualNicManagerInfo.NetConfig {
+		if nc.NicType == "management" && len(nc.CandidateVnic) > 0 {
+			ip := net.ParseIP(nc.CandidateVnic[0].Spec.Ip.IpAddress)
+			if ip != nil {
+				ips = append(ips, ip)
+			}
+		}
+	}
+
+	return ips, nil
+}
+
+func (h HostSystem) Disconnect(ctx context.Context) (*Task, error) {
+	req := types.DisconnectHost_Task{
+		This: h.Reference(),
+	}
+
+	res, err := methods.DisconnectHost_Task(ctx, h.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(h.c, res.Returnval), nil
+}
+
+func (h HostSystem) Reconnect(ctx context.Context, cnxSpec *types.HostConnectSpec, reconnectSpec *types.HostSystemReconnectSpec) (*Task, error) {
+	req := types.ReconnectHost_Task{
+		This:          h.Reference(),
+		CnxSpec:       cnxSpec,
+		ReconnectSpec: reconnectSpec,
+	}
+
+	res, err := methods.ReconnectHost_Task(ctx, h.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(h.c, res.Returnval), nil
+}
+
+func (h HostSystem) EnterMaintenanceMode(ctx context.Context, timeout int32, evacuate bool, spec *types.HostMaintenanceSpec) (*Task, error) {
+	req := types.EnterMaintenanceMode_Task{
+		This:                  h.Reference(),
+		Timeout:               timeout,
+		EvacuatePoweredOffVms: types.NewBool(evacuate),
+		MaintenanceSpec:       spec,
+	}
+
+	res, err := methods.EnterMaintenanceMode_Task(ctx, h.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(h.c, res.Returnval), nil
+}
+
+func (h HostSystem) ExitMaintenanceMode(ctx context.Context, timeout int32) (*Task, error) {
+	req := types.ExitMaintenanceMode_Task{
+		This:    h.Reference(),
+		Timeout: timeout,
+	}
+
+	res, err := methods.ExitMaintenanceMode_Task(ctx, h.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(h.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/host_virtual_nic_manager.go

@@ -0,0 +1,93 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostVirtualNicManager struct {
+	Common
+	Host *HostSystem
+}
+
+func NewHostVirtualNicManager(c *vim25.Client, ref types.ManagedObjectReference, host types.ManagedObjectReference) *HostVirtualNicManager {
+	return &HostVirtualNicManager{
+		Common: NewCommon(c, ref),
+		Host:   NewHostSystem(c, host),
+	}
+}
+
+func (m HostVirtualNicManager) Info(ctx context.Context) (*types.HostVirtualNicManagerInfo, error) {
+	var vnm mo.HostVirtualNicManager
+
+	err := m.Properties(ctx, m.Reference(), []string{"info"}, &vnm)
+	if err != nil {
+		return nil, err
+	}
+
+	return &vnm.Info, nil
+}
+
+func (m HostVirtualNicManager) DeselectVnic(ctx context.Context, nicType string, device string) error {
+	if nicType == string(types.HostVirtualNicManagerNicTypeVsan) {
+		// Avoid fault.NotSupported:
+		// "Error deselecting device '$device': VSAN interfaces must be deselected using vim.host.VsanSystem"
+		s, err := m.Host.ConfigManager().VsanSystem(ctx)
+		if err != nil {
+			return err
+		}
+
+		return s.updateVnic(ctx, device, false)
+	}
+
+	req := types.DeselectVnicForNicType{
+		This:    m.Reference(),
+		NicType: nicType,
+		Device:  device,
+	}
+
+	_, err := methods.DeselectVnicForNicType(ctx, m.Client(), &req)
+	return err
+}
+
+func (m HostVirtualNicManager) SelectVnic(ctx context.Context, nicType string, device string) error {
+	if nicType == string(types.HostVirtualNicManagerNicTypeVsan) {
+		// Avoid fault.NotSupported:
+		// "Error selecting device '$device': VSAN interfaces must be selected using vim.host.VsanSystem"
+		s, err := m.Host.ConfigManager().VsanSystem(ctx)
+		if err != nil {
+			return err
+		}
+
+		return s.updateVnic(ctx, device, true)
+	}
+
+	req := types.SelectVnicForNicType{
+		This:    m.Reference(),
+		NicType: nicType,
+		Device:  device,
+	}
+
+	_, err := methods.SelectVnicForNicType(ctx, m.Client(), &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/host_vsan_internal_system.go

@@ -0,0 +1,117 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostVsanInternalSystem struct {
+	Common
+}
+
+func NewHostVsanInternalSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostVsanInternalSystem {
+	m := HostVsanInternalSystem{
+		Common: NewCommon(c, ref),
+	}
+
+	return &m
+}
+
+// QueryVsanObjectUuidsByFilter returns vSAN DOM object uuids by filter.
+func (m HostVsanInternalSystem) QueryVsanObjectUuidsByFilter(ctx context.Context, uuids []string, limit int32, version int32) ([]string, error) {
+	req := types.QueryVsanObjectUuidsByFilter{
+		This:    m.Reference(),
+		Uuids:   uuids,
+		Limit:   &limit,
+		Version: version,
+	}
+
+	res, err := methods.QueryVsanObjectUuidsByFilter(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+type VsanObjExtAttrs struct {
+	Type  string `json:"Object type"`
+	Class string `json:"Object class"`
+	Size  string `json:"Object size"`
+	Path  string `json:"Object path"`
+	Name  string `json:"User friendly name"`
+}
+
+func (a *VsanObjExtAttrs) DatastorePath(dir string) string {
+	l := len(dir)
+	path := a.Path
+
+	if len(path) >= l {
+		path = a.Path[l:]
+	}
+
+	if path != "" {
+		return path
+	}
+
+	return a.Name // vmnamespace
+}
+
+// GetVsanObjExtAttrs is internal and intended for troubleshooting/debugging situations in the field.
+// WARNING: This API can be slow because we do IOs (reads) to all the objects.
+func (m HostVsanInternalSystem) GetVsanObjExtAttrs(ctx context.Context, uuids []string) (map[string]VsanObjExtAttrs, error) {
+	req := types.GetVsanObjExtAttrs{
+		This:  m.Reference(),
+		Uuids: uuids,
+	}
+
+	res, err := methods.GetVsanObjExtAttrs(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	var attrs map[string]VsanObjExtAttrs
+
+	err = json.Unmarshal([]byte(res.Returnval), &attrs)
+
+	return attrs, err
+}
+
+// DeleteVsanObjects is internal and intended for troubleshooting/debugging only.
+// WARNING: This API can be slow because we do IOs to all the objects.
+// DOM won't allow access to objects which have lost quorum. Such objects can be deleted with the optional "force" flag.
+// These objects may however re-appear with quorum if the absent components come back (network partition gets resolved, etc.)
+func (m HostVsanInternalSystem) DeleteVsanObjects(ctx context.Context, uuids []string, force *bool) ([]types.HostVsanInternalSystemDeleteVsanObjectsResult, error) {
+	req := types.DeleteVsanObjects{
+		This:  m.Reference(),
+		Uuids: uuids,
+		Force: force,
+	}
+
+	res, err := methods.DeleteVsanObjects(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/host_vsan_system.go

@@ -0,0 +1,88 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type HostVsanSystem struct {
+	Common
+}
+
+func NewHostVsanSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostVsanSystem {
+	return &HostVsanSystem{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (s HostVsanSystem) Update(ctx context.Context, config types.VsanHostConfigInfo) (*Task, error) {
+	req := types.UpdateVsan_Task{
+		This:   s.Reference(),
+		Config: config,
+	}
+
+	res, err := methods.UpdateVsan_Task(ctx, s.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(s.Client(), res.Returnval), nil
+}
+
+// updateVnic in support of the HostVirtualNicManager.{SelectVnic,DeselectVnic} methods
+func (s HostVsanSystem) updateVnic(ctx context.Context, device string, enable bool) error {
+	var vsan mo.HostVsanSystem
+
+	err := s.Properties(ctx, s.Reference(), []string{"config.networkInfo.port"}, &vsan)
+	if err != nil {
+		return err
+	}
+
+	info := vsan.Config
+
+	var port []types.VsanHostConfigInfoNetworkInfoPortConfig
+
+	for _, p := range info.NetworkInfo.Port {
+		if p.Device == device {
+			continue
+		}
+
+		port = append(port, p)
+	}
+
+	if enable {
+		port = append(port, types.VsanHostConfigInfoNetworkInfoPortConfig{
+			Device: device,
+		})
+	}
+
+	info.NetworkInfo.Port = port
+
+	task, err := s.Update(ctx, info)
+	if err != nil {
+		return err
+	}
+
+	_, err = task.WaitForResult(ctx, nil)
+	return err
+}

vendor/github.com/vmware/govmomi/object/namespace_manager.go

@@ -0,0 +1,76 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type DatastoreNamespaceManager struct {
+	Common
+}
+
+func NewDatastoreNamespaceManager(c *vim25.Client) *DatastoreNamespaceManager {
+	n := DatastoreNamespaceManager{
+		Common: NewCommon(c, *c.ServiceContent.DatastoreNamespaceManager),
+	}
+
+	return &n
+}
+
+// CreateDirectory creates a top-level directory on the given vsan datastore, using
+// the given user display name hint and opaque storage policy.
+func (nm DatastoreNamespaceManager) CreateDirectory(ctx context.Context, ds *Datastore, displayName string, policy string) (string, error) {
+
+	req := &types.CreateDirectory{
+		This:        nm.Reference(),
+		Datastore:   ds.Reference(),
+		DisplayName: displayName,
+		Policy:      policy,
+	}
+
+	resp, err := methods.CreateDirectory(ctx, nm.c, req)
+	if err != nil {
+		return "", err
+	}
+
+	return resp.Returnval, nil
+}
+
+// DeleteDirectory deletes the given top-level directory from a vsan datastore.
+func (nm DatastoreNamespaceManager) DeleteDirectory(ctx context.Context, dc *Datacenter, datastorePath string) error {
+
+	req := &types.DeleteDirectory{
+		This:          nm.Reference(),
+		DatastorePath: datastorePath,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	if _, err := methods.DeleteDirectory(ctx, nm.c, req); err != nil {
+		return err
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/object/network.go

@@ -0,0 +1,56 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type Network struct {
+	Common
+}
+
+func NewNetwork(c *vim25.Client, ref types.ManagedObjectReference) *Network {
+	return &Network{
+		Common: NewCommon(c, ref),
+	}
+}
+
+// EthernetCardBackingInfo returns the VirtualDeviceBackingInfo for this Network
+func (n Network) EthernetCardBackingInfo(ctx context.Context) (types.BaseVirtualDeviceBackingInfo, error) {
+	var e mo.Network
+
+	// Use Network.Name rather than Common.Name as the latter does not return the complete name if it contains a '/'
+	// We can't use Common.ObjectName here either as we need the ManagedEntity.Name field is not set since mo.Network
+	// has its own Name field.
+	err := n.Properties(ctx, n.Reference(), []string{"name"}, &e)
+	if err != nil {
+		return nil, err
+	}
+
+	backing := &types.VirtualEthernetCardNetworkBackingInfo{
+		VirtualDeviceDeviceBackingInfo: types.VirtualDeviceDeviceBackingInfo{
+			DeviceName: e.Name,
+		},
+	}
+
+	return backing, nil
+}

vendor/github.com/vmware/govmomi/object/network_reference.go

@@ -0,0 +1,31 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// The NetworkReference interface is implemented by managed objects
+// which can be used as the backing for a VirtualEthernetCard.
+type NetworkReference interface {
+	Reference
+
+	EthernetCardBackingInfo(ctx context.Context) (types.BaseVirtualDeviceBackingInfo, error)
+}

vendor/github.com/vmware/govmomi/object/network_test.go

@@ -0,0 +1,23 @@
+/*
+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 object
+
+// Network should implement the Reference interface.
+var _ Reference = Network{}
+
+// Network should implement the NetworkReference interface.
+var _ NetworkReference = Network{}

vendor/github.com/vmware/govmomi/object/opaque_network.go

@@ -0,0 +1,57 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type OpaqueNetwork struct {
+	Common
+}
+
+func NewOpaqueNetwork(c *vim25.Client, ref types.ManagedObjectReference) *OpaqueNetwork {
+	return &OpaqueNetwork{
+		Common: NewCommon(c, ref),
+	}
+}
+
+// EthernetCardBackingInfo returns the VirtualDeviceBackingInfo for this Network
+func (n OpaqueNetwork) EthernetCardBackingInfo(ctx context.Context) (types.BaseVirtualDeviceBackingInfo, error) {
+	var net mo.OpaqueNetwork
+
+	if err := n.Properties(ctx, n.Reference(), []string{"summary"}, &net); err != nil {
+		return nil, err
+	}
+
+	summary, ok := net.Summary.(*types.OpaqueNetworkSummary)
+	if !ok {
+		return nil, fmt.Errorf("%s unsupported network type: %T", n, net.Summary)
+	}
+
+	backing := &types.VirtualEthernetCardOpaqueNetworkBackingInfo{
+		OpaqueNetworkId:   summary.OpaqueNetworkId,
+		OpaqueNetworkType: summary.OpaqueNetworkType,
+	}
+
+	return backing, nil
+}

vendor/github.com/vmware/govmomi/object/option_manager.go

@@ -0,0 +1,59 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type OptionManager struct {
+	Common
+}
+
+func NewOptionManager(c *vim25.Client, ref types.ManagedObjectReference) *OptionManager {
+	return &OptionManager{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (m OptionManager) Query(ctx context.Context, name string) ([]types.BaseOptionValue, error) {
+	req := types.QueryOptions{
+		This: m.Reference(),
+		Name: name,
+	}
+
+	res, err := methods.QueryOptions(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (m OptionManager) Update(ctx context.Context, value []types.BaseOptionValue) error {
+	req := types.UpdateOptions{
+		This:         m.Reference(),
+		ChangedValue: value,
+	}
+
+	_, err := methods.UpdateOptions(ctx, m.Client(), &req)
+	return err
+}

vendor/github.com/vmware/govmomi/object/resource_pool.go

@@ -0,0 +1,138 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/nfc"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ResourcePool struct {
+	Common
+}
+
+func NewResourcePool(c *vim25.Client, ref types.ManagedObjectReference) *ResourcePool {
+	return &ResourcePool{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (p ResourcePool) ImportVApp(ctx context.Context, spec types.BaseImportSpec, folder *Folder, host *HostSystem) (*nfc.Lease, error) {
+	req := types.ImportVApp{
+		This: p.Reference(),
+		Spec: spec,
+	}
+
+	if folder != nil {
+		ref := folder.Reference()
+		req.Folder = &ref
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	res, err := methods.ImportVApp(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return nfc.NewLease(p.c, res.Returnval), nil
+}
+
+func (p ResourcePool) Create(ctx context.Context, name string, spec types.ResourceConfigSpec) (*ResourcePool, error) {
+	req := types.CreateResourcePool{
+		This: p.Reference(),
+		Name: name,
+		Spec: spec,
+	}
+
+	res, err := methods.CreateResourcePool(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewResourcePool(p.c, res.Returnval), nil
+}
+
+func (p ResourcePool) CreateVApp(ctx context.Context, name string, resSpec types.ResourceConfigSpec, configSpec types.VAppConfigSpec, folder *Folder) (*VirtualApp, error) {
+	req := types.CreateVApp{
+		This:       p.Reference(),
+		Name:       name,
+		ResSpec:    resSpec,
+		ConfigSpec: configSpec,
+	}
+
+	if folder != nil {
+		ref := folder.Reference()
+		req.VmFolder = &ref
+	}
+
+	res, err := methods.CreateVApp(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewVirtualApp(p.c, res.Returnval), nil
+}
+
+func (p ResourcePool) UpdateConfig(ctx context.Context, name string, config *types.ResourceConfigSpec) error {
+	req := types.UpdateConfig{
+		This:   p.Reference(),
+		Name:   name,
+		Config: config,
+	}
+
+	if config != nil && config.Entity == nil {
+		ref := p.Reference()
+
+		// Create copy of config so changes won't leak back to the caller
+		newConfig := *config
+		newConfig.Entity = &ref
+		req.Config = &newConfig
+	}
+
+	_, err := methods.UpdateConfig(ctx, p.c, &req)
+	return err
+}
+
+func (p ResourcePool) DestroyChildren(ctx context.Context) error {
+	req := types.DestroyChildren{
+		This: p.Reference(),
+	}
+
+	_, err := methods.DestroyChildren(ctx, p.c, &req)
+	return err
+}
+
+func (p ResourcePool) Destroy(ctx context.Context) (*Task, error) {
+	req := types.Destroy_Task{
+		This: p.Reference(),
+	}
+
+	res, err := methods.Destroy_Task(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(p.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/search_index.go

@@ -0,0 +1,163 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type SearchIndex struct {
+	Common
+}
+
+func NewSearchIndex(c *vim25.Client) *SearchIndex {
+	s := SearchIndex{
+		Common: NewCommon(c, *c.ServiceContent.SearchIndex),
+	}
+
+	return &s
+}
+
+// FindByDatastorePath finds a virtual machine by its location on a datastore.
+func (s SearchIndex) FindByDatastorePath(ctx context.Context, dc *Datacenter, path string) (Reference, error) {
+	req := types.FindByDatastorePath{
+		This:       s.Reference(),
+		Datacenter: dc.Reference(),
+		Path:       path,
+	}
+
+	res, err := methods.FindByDatastorePath(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil {
+		return nil, nil
+	}
+	return NewReference(s.c, *res.Returnval), nil
+}
+
+// FindByDnsName finds a virtual machine or host by DNS name.
+func (s SearchIndex) FindByDnsName(ctx context.Context, dc *Datacenter, dnsName string, vmSearch bool) (Reference, error) {
+	req := types.FindByDnsName{
+		This:     s.Reference(),
+		DnsName:  dnsName,
+		VmSearch: vmSearch,
+	}
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.FindByDnsName(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil {
+		return nil, nil
+	}
+	return NewReference(s.c, *res.Returnval), nil
+}
+
+// FindByInventoryPath finds a managed entity based on its location in the inventory.
+func (s SearchIndex) FindByInventoryPath(ctx context.Context, path string) (Reference, error) {
+	req := types.FindByInventoryPath{
+		This:          s.Reference(),
+		InventoryPath: path,
+	}
+
+	res, err := methods.FindByInventoryPath(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil {
+		return nil, nil
+	}
+	return NewReference(s.c, *res.Returnval), nil
+}
+
+// FindByIp finds a virtual machine or host by IP address.
+func (s SearchIndex) FindByIp(ctx context.Context, dc *Datacenter, ip string, vmSearch bool) (Reference, error) {
+	req := types.FindByIp{
+		This:     s.Reference(),
+		Ip:       ip,
+		VmSearch: vmSearch,
+	}
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.FindByIp(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil {
+		return nil, nil
+	}
+	return NewReference(s.c, *res.Returnval), nil
+}
+
+// FindByUuid finds a virtual machine or host by UUID.
+func (s SearchIndex) FindByUuid(ctx context.Context, dc *Datacenter, uuid string, vmSearch bool, instanceUuid *bool) (Reference, error) {
+	req := types.FindByUuid{
+		This:         s.Reference(),
+		Uuid:         uuid,
+		VmSearch:     vmSearch,
+		InstanceUuid: instanceUuid,
+	}
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.FindByUuid(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil {
+		return nil, nil
+	}
+	return NewReference(s.c, *res.Returnval), nil
+}
+
+// FindChild finds a particular child based on a managed entity name.
+func (s SearchIndex) FindChild(ctx context.Context, entity Reference, name string) (Reference, error) {
+	req := types.FindChild{
+		This:   s.Reference(),
+		Entity: entity.Reference(),
+		Name:   name,
+	}
+
+	res, err := methods.FindChild(ctx, s.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.Returnval == nil {
+		return nil, nil
+	}
+	return NewReference(s.c, *res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/search_index_test.go

@@ -0,0 +1,155 @@
+/*
+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 object
+
+import (
+	"context"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/vmware/govmomi/test"
+	"github.com/vmware/govmomi/vim25/mo"
+)
+
+func TestSearch(t *testing.T) {
+	c := test.NewAuthenticatedClient(t)
+	s := NewSearchIndex(c)
+
+	ref, err := s.FindChild(context.Background(), NewRootFolder(c), "ha-datacenter")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dc, ok := ref.(*Datacenter)
+	if !ok {
+		t.Errorf("Expected Datacenter: %#v", ref)
+	}
+
+	folders, err := dc.Folders(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ref, err = s.FindChild(context.Background(), folders.DatastoreFolder, "datastore1")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, ok = ref.(*Datastore)
+	if !ok {
+		t.Errorf("Expected Datastore: %#v", ref)
+	}
+
+	ref, err = s.FindByInventoryPath(context.Background(), "/ha-datacenter/network/VM Network")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, ok = ref.(*Network)
+	if !ok {
+		t.Errorf("Expected Network: %#v", ref)
+	}
+
+	crs, err := folders.HostFolder.Children(context.Background())
+	if err != nil {
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	if len(crs) != 0 {
+		var cr mo.ComputeResource
+		ref = crs[0]
+		err = s.Properties(context.Background(), ref.Reference(), []string{"host"}, &cr)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		var host mo.HostSystem
+		ref = NewHostSystem(c, cr.Host[0])
+		err = s.Properties(context.Background(), ref.Reference(), []string{"name", "hardware", "config"}, &host)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		dnsConfig := host.Config.Network.DnsConfig.GetHostDnsConfig()
+		dnsName := fmt.Sprintf("%s.%s", dnsConfig.HostName, dnsConfig.DomainName)
+		shost, err := s.FindByDnsName(context.Background(), dc, dnsName, false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ref, shost) {
+			t.Errorf("%#v != %#v\n", ref, shost)
+		}
+
+		shost, err = s.FindByUuid(context.Background(), dc, host.Hardware.SystemInfo.Uuid, false, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ref, shost) {
+			t.Errorf("%#v != %#v\n", ref, shost)
+		}
+	}
+
+	vms, err := folders.VmFolder.Children(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(vms) != 0 {
+		var vm mo.VirtualMachine
+		ref = vms[0]
+		err = s.Properties(context.Background(), ref.Reference(), []string{"config", "guest"}, &vm)
+		if err != nil {
+			t.Fatal(err)
+		}
+		svm, err := s.FindByDatastorePath(context.Background(), dc, vm.Config.Files.VmPathName)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ref, svm) {
+			t.Errorf("%#v != %#v\n", ref, svm)
+		}
+
+		svm, err = s.FindByUuid(context.Background(), dc, vm.Config.Uuid, true, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(ref, svm) {
+			t.Errorf("%#v != %#v\n", ref, svm)
+		}
+
+		if vm.Guest.HostName != "" {
+			svm, err := s.FindByDnsName(context.Background(), dc, vm.Guest.HostName, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(ref, svm) {
+				t.Errorf("%#v != %#v\n", ref, svm)
+			}
+		}
+
+		if vm.Guest.IpAddress != "" {
+			svm, err := s.FindByIp(context.Background(), dc, vm.Guest.IpAddress, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(ref, svm) {
+				t.Errorf("%#v != %#v\n", ref, svm)
+			}
+		}
+	}
+}

vendor/github.com/vmware/govmomi/object/storage_pod.go

@@ -0,0 +1,34 @@
+/*
+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 object
+
+import (
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type StoragePod struct {
+	*Folder
+}
+
+func NewStoragePod(c *vim25.Client, ref types.ManagedObjectReference) *StoragePod {
+	return &StoragePod{
+		Folder: &Folder{
+			Common: NewCommon(c, ref),
+		},
+	}
+}

vendor/github.com/vmware/govmomi/object/storage_resource_manager.go

@@ -0,0 +1,179 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type StorageResourceManager struct {
+	Common
+}
+
+func NewStorageResourceManager(c *vim25.Client) *StorageResourceManager {
+	sr := StorageResourceManager{
+		Common: NewCommon(c, *c.ServiceContent.StorageResourceManager),
+	}
+
+	return &sr
+}
+
+func (sr StorageResourceManager) ApplyStorageDrsRecommendation(ctx context.Context, key []string) (*Task, error) {
+	req := types.ApplyStorageDrsRecommendation_Task{
+		This: sr.Reference(),
+		Key:  key,
+	}
+
+	res, err := methods.ApplyStorageDrsRecommendation_Task(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(sr.c, res.Returnval), nil
+}
+
+func (sr StorageResourceManager) ApplyStorageDrsRecommendationToPod(ctx context.Context, pod *StoragePod, key string) (*Task, error) {
+	req := types.ApplyStorageDrsRecommendationToPod_Task{
+		This: sr.Reference(),
+		Key:  key,
+	}
+
+	if pod != nil {
+		req.Pod = pod.Reference()
+	}
+
+	res, err := methods.ApplyStorageDrsRecommendationToPod_Task(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(sr.c, res.Returnval), nil
+}
+
+func (sr StorageResourceManager) CancelStorageDrsRecommendation(ctx context.Context, key []string) error {
+	req := types.CancelStorageDrsRecommendation{
+		This: sr.Reference(),
+		Key:  key,
+	}
+
+	_, err := methods.CancelStorageDrsRecommendation(ctx, sr.c, &req)
+
+	return err
+}
+
+func (sr StorageResourceManager) ConfigureDatastoreIORM(ctx context.Context, datastore *Datastore, spec types.StorageIORMConfigSpec, key string) (*Task, error) {
+	req := types.ConfigureDatastoreIORM_Task{
+		This: sr.Reference(),
+		Spec: spec,
+	}
+
+	if datastore != nil {
+		req.Datastore = datastore.Reference()
+	}
+
+	res, err := methods.ConfigureDatastoreIORM_Task(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(sr.c, res.Returnval), nil
+}
+
+func (sr StorageResourceManager) ConfigureStorageDrsForPod(ctx context.Context, pod *StoragePod, spec types.StorageDrsConfigSpec, modify bool) (*Task, error) {
+	req := types.ConfigureStorageDrsForPod_Task{
+		This:   sr.Reference(),
+		Spec:   spec,
+		Modify: modify,
+	}
+
+	if pod != nil {
+		req.Pod = pod.Reference()
+	}
+
+	res, err := methods.ConfigureStorageDrsForPod_Task(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(sr.c, res.Returnval), nil
+}
+
+func (sr StorageResourceManager) QueryDatastorePerformanceSummary(ctx context.Context, datastore *Datastore) ([]types.StoragePerformanceSummary, error) {
+	req := types.QueryDatastorePerformanceSummary{
+		This: sr.Reference(),
+	}
+
+	if datastore != nil {
+		req.Datastore = datastore.Reference()
+	}
+
+	res, err := methods.QueryDatastorePerformanceSummary(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (sr StorageResourceManager) QueryIORMConfigOption(ctx context.Context, host *HostSystem) (*types.StorageIORMConfigOption, error) {
+	req := types.QueryIORMConfigOption{
+		This: sr.Reference(),
+	}
+
+	if host != nil {
+		req.Host = host.Reference()
+	}
+
+	res, err := methods.QueryIORMConfigOption(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (sr StorageResourceManager) RecommendDatastores(ctx context.Context, storageSpec types.StoragePlacementSpec) (*types.StoragePlacementResult, error) {
+	req := types.RecommendDatastores{
+		This:        sr.Reference(),
+		StorageSpec: storageSpec,
+	}
+
+	res, err := methods.RecommendDatastores(ctx, sr.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+func (sr StorageResourceManager) RefreshStorageDrsRecommendation(ctx context.Context, pod *StoragePod) error {
+	req := types.RefreshStorageDrsRecommendation{
+		This: sr.Reference(),
+	}
+
+	if pod != nil {
+		req.Pod = pod.Reference()
+	}
+
+	_, err := methods.RefreshStorageDrsRecommendation(ctx, sr.c, &req)
+
+	return err
+}

vendor/github.com/vmware/govmomi/object/task.go

@@ -0,0 +1,62 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/task"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/progress"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Task is a convenience wrapper around task.Task that keeps a reference to
+// the client that was used to create it. This allows users to call the Wait()
+// function with only a context parameter, instead of a context parameter, a
+// soap.RoundTripper, and reference to the root property collector.
+type Task struct {
+	Common
+}
+
+func NewTask(c *vim25.Client, ref types.ManagedObjectReference) *Task {
+	t := Task{
+		Common: NewCommon(c, ref),
+	}
+
+	return &t
+}
+
+func (t *Task) Wait(ctx context.Context) error {
+	_, err := t.WaitForResult(ctx, nil)
+	return err
+}
+
+func (t *Task) WaitForResult(ctx context.Context, s progress.Sinker) (*types.TaskInfo, error) {
+	p := property.DefaultCollector(t.c)
+	return task.Wait(ctx, t.Reference(), p, s)
+}
+
+func (t *Task) Cancel(ctx context.Context) error {
+	_, err := methods.CancelTask(ctx, t.Client(), &types.CancelTask{
+		This: t.Reference(),
+	})
+
+	return err
+}

vendor/github.com/vmware/govmomi/object/types.go

@@ -0,0 +1,67 @@
+/*
+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 object
+
+import (
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type Reference interface {
+	Reference() types.ManagedObjectReference
+}
+
+func NewReference(c *vim25.Client, e types.ManagedObjectReference) Reference {
+	switch e.Type {
+	case "Folder":
+		return NewFolder(c, e)
+	case "StoragePod":
+		return &StoragePod{
+			NewFolder(c, e),
+		}
+	case "Datacenter":
+		return NewDatacenter(c, e)
+	case "VirtualMachine":
+		return NewVirtualMachine(c, e)
+	case "VirtualApp":
+		return &VirtualApp{
+			NewResourcePool(c, e),
+		}
+	case "ComputeResource":
+		return NewComputeResource(c, e)
+	case "ClusterComputeResource":
+		return NewClusterComputeResource(c, e)
+	case "HostSystem":
+		return NewHostSystem(c, e)
+	case "Network":
+		return NewNetwork(c, e)
+	case "OpaqueNetwork":
+		return NewOpaqueNetwork(c, e)
+	case "ResourcePool":
+		return NewResourcePool(c, e)
+	case "DistributedVirtualSwitch":
+		return NewDistributedVirtualSwitch(c, e)
+	case "VmwareDistributedVirtualSwitch":
+		return &VmwareDistributedVirtualSwitch{*NewDistributedVirtualSwitch(c, e)}
+	case "DistributedVirtualPortgroup":
+		return NewDistributedVirtualPortgroup(c, e)
+	case "Datastore":
+		return NewDatastore(c, e)
+	default:
+		panic("Unknown managed entity: " + e.Type)
+	}
+}

vendor/github.com/vmware/govmomi/object/virtual_app.go

@@ -0,0 +1,105 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type VirtualApp struct {
+	*ResourcePool
+}
+
+func NewVirtualApp(c *vim25.Client, ref types.ManagedObjectReference) *VirtualApp {
+	return &VirtualApp{
+		ResourcePool: NewResourcePool(c, ref),
+	}
+}
+
+func (p VirtualApp) CreateChildVM(ctx context.Context, config types.VirtualMachineConfigSpec, host *HostSystem) (*Task, error) {
+	req := types.CreateChildVM_Task{
+		This:   p.Reference(),
+		Config: config,
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	res, err := methods.CreateChildVM_Task(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(p.c, res.Returnval), nil
+}
+
+func (p VirtualApp) UpdateConfig(ctx context.Context, spec types.VAppConfigSpec) error {
+	req := types.UpdateVAppConfig{
+		This: p.Reference(),
+		Spec: spec,
+	}
+
+	_, err := methods.UpdateVAppConfig(ctx, p.c, &req)
+	return err
+}
+
+func (p VirtualApp) PowerOn(ctx context.Context) (*Task, error) {
+	req := types.PowerOnVApp_Task{
+		This: p.Reference(),
+	}
+
+	res, err := methods.PowerOnVApp_Task(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(p.c, res.Returnval), nil
+}
+
+func (p VirtualApp) PowerOff(ctx context.Context, force bool) (*Task, error) {
+	req := types.PowerOffVApp_Task{
+		This:  p.Reference(),
+		Force: force,
+	}
+
+	res, err := methods.PowerOffVApp_Task(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(p.c, res.Returnval), nil
+
+}
+
+func (p VirtualApp) Suspend(ctx context.Context) (*Task, error) {
+	req := types.SuspendVApp_Task{
+		This: p.Reference(),
+	}
+
+	res, err := methods.SuspendVApp_Task(ctx, p.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(p.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/virtual_device_list.go

@@ -0,0 +1,932 @@
+/*
+Copyright (c) 2015-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 object
+
+import (
+	"errors"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// Type values for use in BootOrder
+const (
+	DeviceTypeNone     = "-"
+	DeviceTypeCdrom    = "cdrom"
+	DeviceTypeDisk     = "disk"
+	DeviceTypeEthernet = "ethernet"
+	DeviceTypeFloppy   = "floppy"
+)
+
+// VirtualDeviceList provides helper methods for working with a list of virtual devices.
+type VirtualDeviceList []types.BaseVirtualDevice
+
+// SCSIControllerTypes are used for adding a new SCSI controller to a VM.
+func SCSIControllerTypes() VirtualDeviceList {
+	// Return a mutable list of SCSI controller types, initialized with defaults.
+	return VirtualDeviceList([]types.BaseVirtualDevice{
+		&types.VirtualLsiLogicController{},
+		&types.VirtualBusLogicController{},
+		&types.ParaVirtualSCSIController{},
+		&types.VirtualLsiLogicSASController{},
+	}).Select(func(device types.BaseVirtualDevice) bool {
+		c := device.(types.BaseVirtualSCSIController).GetVirtualSCSIController()
+		c.SharedBus = types.VirtualSCSISharingNoSharing
+		c.BusNumber = -1
+		return true
+	})
+}
+
+// EthernetCardTypes are used for adding a new ethernet card to a VM.
+func EthernetCardTypes() VirtualDeviceList {
+	return VirtualDeviceList([]types.BaseVirtualDevice{
+		&types.VirtualE1000{},
+		&types.VirtualE1000e{},
+		&types.VirtualVmxnet3{},
+	}).Select(func(device types.BaseVirtualDevice) bool {
+		c := device.(types.BaseVirtualEthernetCard).GetVirtualEthernetCard()
+		c.GetVirtualDevice().Key = -1
+		return true
+	})
+}
+
+// Select returns a new list containing all elements of the list for which the given func returns true.
+func (l VirtualDeviceList) Select(f func(device types.BaseVirtualDevice) bool) VirtualDeviceList {
+	var found VirtualDeviceList
+
+	for _, device := range l {
+		if f(device) {
+			found = append(found, device)
+		}
+	}
+
+	return found
+}
+
+// SelectByType returns a new list with devices that are equal to or extend the given type.
+func (l VirtualDeviceList) SelectByType(deviceType types.BaseVirtualDevice) VirtualDeviceList {
+	dtype := reflect.TypeOf(deviceType)
+	if dtype == nil {
+		return nil
+	}
+	dname := dtype.Elem().Name()
+
+	return l.Select(func(device types.BaseVirtualDevice) bool {
+		t := reflect.TypeOf(device)
+
+		if t == dtype {
+			return true
+		}
+
+		_, ok := t.Elem().FieldByName(dname)
+
+		return ok
+	})
+}
+
+// SelectByBackingInfo returns a new list with devices matching the given backing info.
+// If the value of backing is nil, any device with a backing of the same type will be returned.
+func (l VirtualDeviceList) SelectByBackingInfo(backing types.BaseVirtualDeviceBackingInfo) VirtualDeviceList {
+	t := reflect.TypeOf(backing)
+
+	return l.Select(func(device types.BaseVirtualDevice) bool {
+		db := device.GetVirtualDevice().Backing
+		if db == nil {
+			return false
+		}
+
+		if reflect.TypeOf(db) != t {
+			return false
+		}
+
+		if reflect.ValueOf(backing).IsNil() {
+			// selecting by backing type
+			return true
+		}
+
+		switch a := db.(type) {
+		case *types.VirtualEthernetCardNetworkBackingInfo:
+			b := backing.(*types.VirtualEthernetCardNetworkBackingInfo)
+			return a.DeviceName == b.DeviceName
+		case *types.VirtualEthernetCardDistributedVirtualPortBackingInfo:
+			b := backing.(*types.VirtualEthernetCardDistributedVirtualPortBackingInfo)
+			return a.Port.SwitchUuid == b.Port.SwitchUuid &&
+				a.Port.PortgroupKey == b.Port.PortgroupKey
+		case *types.VirtualDiskFlatVer2BackingInfo:
+			b := backing.(*types.VirtualDiskFlatVer2BackingInfo)
+			if a.Parent != nil && b.Parent != nil {
+				return a.Parent.FileName == b.Parent.FileName
+			}
+			return a.FileName == b.FileName
+		case *types.VirtualSerialPortURIBackingInfo:
+			b := backing.(*types.VirtualSerialPortURIBackingInfo)
+			return a.ServiceURI == b.ServiceURI
+		case types.BaseVirtualDeviceFileBackingInfo:
+			b := backing.(types.BaseVirtualDeviceFileBackingInfo)
+			return a.GetVirtualDeviceFileBackingInfo().FileName == b.GetVirtualDeviceFileBackingInfo().FileName
+		default:
+			return false
+		}
+	})
+}
+
+// Find returns the device matching the given name.
+func (l VirtualDeviceList) Find(name string) types.BaseVirtualDevice {
+	for _, device := range l {
+		if l.Name(device) == name {
+			return device
+		}
+	}
+	return nil
+}
+
+// FindByKey returns the device matching the given key.
+func (l VirtualDeviceList) FindByKey(key int32) types.BaseVirtualDevice {
+	for _, device := range l {
+		if device.GetVirtualDevice().Key == key {
+			return device
+		}
+	}
+	return nil
+}
+
+// FindIDEController will find the named IDE controller if given, otherwise will pick an available controller.
+// An error is returned if the named controller is not found or not an IDE controller.  Or, if name is not
+// given and no available controller can be found.
+func (l VirtualDeviceList) FindIDEController(name string) (*types.VirtualIDEController, error) {
+	if name != "" {
+		d := l.Find(name)
+		if d == nil {
+			return nil, fmt.Errorf("device '%s' not found", name)
+		}
+		if c, ok := d.(*types.VirtualIDEController); ok {
+			return c, nil
+		}
+		return nil, fmt.Errorf("%s is not an IDE controller", name)
+	}
+
+	c := l.PickController((*types.VirtualIDEController)(nil))
+	if c == nil {
+		return nil, errors.New("no available IDE controller")
+	}
+
+	return c.(*types.VirtualIDEController), nil
+}
+
+// CreateIDEController creates a new IDE controller.
+func (l VirtualDeviceList) CreateIDEController() (types.BaseVirtualDevice, error) {
+	ide := &types.VirtualIDEController{}
+	ide.Key = l.NewKey()
+	return ide, nil
+}
+
+// FindSCSIController will find the named SCSI controller if given, otherwise will pick an available controller.
+// An error is returned if the named controller is not found or not an SCSI controller.  Or, if name is not
+// given and no available controller can be found.
+func (l VirtualDeviceList) FindSCSIController(name string) (*types.VirtualSCSIController, error) {
+	if name != "" {
+		d := l.Find(name)
+		if d == nil {
+			return nil, fmt.Errorf("device '%s' not found", name)
+		}
+		if c, ok := d.(types.BaseVirtualSCSIController); ok {
+			return c.GetVirtualSCSIController(), nil
+		}
+		return nil, fmt.Errorf("%s is not an SCSI controller", name)
+	}
+
+	c := l.PickController((*types.VirtualSCSIController)(nil))
+	if c == nil {
+		return nil, errors.New("no available SCSI controller")
+	}
+
+	return c.(types.BaseVirtualSCSIController).GetVirtualSCSIController(), nil
+}
+
+// CreateSCSIController creates a new SCSI controller of type name if given, otherwise defaults to lsilogic.
+func (l VirtualDeviceList) CreateSCSIController(name string) (types.BaseVirtualDevice, error) {
+	ctypes := SCSIControllerTypes()
+
+	if name == "scsi" || name == "" {
+		name = ctypes.Type(ctypes[0])
+	}
+
+	found := ctypes.Select(func(device types.BaseVirtualDevice) bool {
+		return l.Type(device) == name
+	})
+
+	if len(found) == 0 {
+		return nil, fmt.Errorf("unknown SCSI controller type '%s'", name)
+	}
+
+	c, ok := found[0].(types.BaseVirtualSCSIController)
+	if !ok {
+		return nil, fmt.Errorf("invalid SCSI controller type '%s'", name)
+	}
+
+	scsi := c.GetVirtualSCSIController()
+	scsi.BusNumber = l.newSCSIBusNumber()
+	scsi.Key = l.NewKey()
+	scsi.ScsiCtlrUnitNumber = 7
+	return c.(types.BaseVirtualDevice), nil
+}
+
+var scsiBusNumbers = []int{0, 1, 2, 3}
+
+// newSCSIBusNumber returns the bus number to use for adding a new SCSI bus device.
+// -1 is returned if there are no bus numbers available.
+func (l VirtualDeviceList) newSCSIBusNumber() int32 {
+	var used []int
+
+	for _, d := range l.SelectByType((*types.VirtualSCSIController)(nil)) {
+		num := d.(types.BaseVirtualSCSIController).GetVirtualSCSIController().BusNumber
+		if num >= 0 {
+			used = append(used, int(num))
+		} // else caller is creating a new vm using SCSIControllerTypes
+	}
+
+	sort.Ints(used)
+
+	for i, n := range scsiBusNumbers {
+		if i == len(used) || n != used[i] {
+			return int32(n)
+		}
+	}
+
+	return -1
+}
+
+// FindNVMEController will find the named NVME controller if given, otherwise will pick an available controller.
+// An error is returned if the named controller is not found or not an NVME controller.  Or, if name is not
+// given and no available controller can be found.
+func (l VirtualDeviceList) FindNVMEController(name string) (*types.VirtualNVMEController, error) {
+	if name != "" {
+		d := l.Find(name)
+		if d == nil {
+			return nil, fmt.Errorf("device '%s' not found", name)
+		}
+		if c, ok := d.(*types.VirtualNVMEController); ok {
+			return c, nil
+		}
+		return nil, fmt.Errorf("%s is not an NVME controller", name)
+	}
+
+	c := l.PickController((*types.VirtualNVMEController)(nil))
+	if c == nil {
+		return nil, errors.New("no available NVME controller")
+	}
+
+	return c.(*types.VirtualNVMEController), nil
+}
+
+// CreateNVMEController creates a new NVMWE controller.
+func (l VirtualDeviceList) CreateNVMEController() (types.BaseVirtualDevice, error) {
+	nvme := &types.VirtualNVMEController{}
+	nvme.BusNumber = l.newNVMEBusNumber()
+	nvme.Key = l.NewKey()
+
+	return nvme, nil
+}
+
+var nvmeBusNumbers = []int{0, 1, 2, 3}
+
+// newNVMEBusNumber returns the bus number to use for adding a new NVME bus device.
+// -1 is returned if there are no bus numbers available.
+func (l VirtualDeviceList) newNVMEBusNumber() int32 {
+	var used []int
+
+	for _, d := range l.SelectByType((*types.VirtualNVMEController)(nil)) {
+		num := d.(types.BaseVirtualController).GetVirtualController().BusNumber
+		if num >= 0 {
+			used = append(used, int(num))
+		} // else caller is creating a new vm using NVMEControllerTypes
+	}
+
+	sort.Ints(used)
+
+	for i, n := range nvmeBusNumbers {
+		if i == len(used) || n != used[i] {
+			return int32(n)
+		}
+	}
+
+	return -1
+}
+
+// FindDiskController will find an existing ide or scsi disk controller.
+func (l VirtualDeviceList) FindDiskController(name string) (types.BaseVirtualController, error) {
+	switch {
+	case name == "ide":
+		return l.FindIDEController("")
+	case name == "scsi" || name == "":
+		return l.FindSCSIController("")
+	case name == "nvme":
+		return l.FindNVMEController("")
+	default:
+		if c, ok := l.Find(name).(types.BaseVirtualController); ok {
+			return c, nil
+		}
+		return nil, fmt.Errorf("%s is not a valid controller", name)
+	}
+}
+
+// PickController returns a controller of the given type(s).
+// If no controllers are found or have no available slots, then nil is returned.
+func (l VirtualDeviceList) PickController(kind types.BaseVirtualController) types.BaseVirtualController {
+	l = l.SelectByType(kind.(types.BaseVirtualDevice)).Select(func(device types.BaseVirtualDevice) bool {
+		num := len(device.(types.BaseVirtualController).GetVirtualController().Device)
+
+		switch device.(type) {
+		case types.BaseVirtualSCSIController:
+			return num < 15
+		case *types.VirtualIDEController:
+			return num < 2
+		case *types.VirtualNVMEController:
+			return num < 8
+		default:
+			return true
+		}
+	})
+
+	if len(l) == 0 {
+		return nil
+	}
+
+	return l[0].(types.BaseVirtualController)
+}
+
+// newUnitNumber returns the unit number to use for attaching a new device to the given controller.
+func (l VirtualDeviceList) newUnitNumber(c types.BaseVirtualController) int32 {
+	units := make([]bool, 30)
+
+	switch sc := c.(type) {
+	case types.BaseVirtualSCSIController:
+		//  The SCSI controller sits on its own bus
+		units[sc.GetVirtualSCSIController().ScsiCtlrUnitNumber] = true
+	}
+
+	key := c.GetVirtualController().Key
+
+	for _, device := range l {
+		d := device.GetVirtualDevice()
+
+		if d.ControllerKey == key && d.UnitNumber != nil {
+			units[int(*d.UnitNumber)] = true
+		}
+	}
+
+	for unit, used := range units {
+		if !used {
+			return int32(unit)
+		}
+	}
+
+	return -1
+}
+
+// NewKey returns the key to use for adding a new device to the device list.
+// The device list we're working with here may not be complete (e.g. when
+// we're only adding new devices), so any positive keys could conflict with device keys
+// that are already in use. To avoid this type of conflict, we can use negative keys
+// here, which will be resolved to positive keys by vSphere as the reconfiguration is done.
+func (l VirtualDeviceList) NewKey() int32 {
+	var key int32 = -200
+
+	for _, device := range l {
+		d := device.GetVirtualDevice()
+		if d.Key < key {
+			key = d.Key
+		}
+	}
+
+	return key - 1
+}
+
+// AssignController assigns a device to a controller.
+func (l VirtualDeviceList) AssignController(device types.BaseVirtualDevice, c types.BaseVirtualController) {
+	d := device.GetVirtualDevice()
+	d.ControllerKey = c.GetVirtualController().Key
+	d.UnitNumber = new(int32)
+	*d.UnitNumber = l.newUnitNumber(c)
+	if d.Key == 0 {
+		d.Key = -1
+	}
+}
+
+// CreateDisk creates a new VirtualDisk device which can be added to a VM.
+func (l VirtualDeviceList) CreateDisk(c types.BaseVirtualController, ds types.ManagedObjectReference, name string) *types.VirtualDisk {
+	// If name is not specified, one will be chosen for you.
+	// But if when given, make sure it ends in .vmdk, otherwise it will be treated as a directory.
+	if len(name) > 0 && filepath.Ext(name) != ".vmdk" {
+		name += ".vmdk"
+	}
+
+	device := &types.VirtualDisk{
+		VirtualDevice: types.VirtualDevice{
+			Backing: &types.VirtualDiskFlatVer2BackingInfo{
+				DiskMode:        string(types.VirtualDiskModePersistent),
+				ThinProvisioned: types.NewBool(true),
+				VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+					FileName:  name,
+					Datastore: &ds,
+				},
+			},
+		},
+	}
+
+	l.AssignController(device, c)
+	return device
+}
+
+// ChildDisk creates a new VirtualDisk device, linked to the given parent disk, which can be added to a VM.
+func (l VirtualDeviceList) ChildDisk(parent *types.VirtualDisk) *types.VirtualDisk {
+	disk := *parent
+	backing := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo)
+	p := new(DatastorePath)
+	p.FromString(backing.FileName)
+	p.Path = ""
+
+	// Use specified disk as parent backing to a new disk.
+	disk.Backing = &types.VirtualDiskFlatVer2BackingInfo{
+		VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+			FileName:  p.String(),
+			Datastore: backing.Datastore,
+		},
+		Parent:          backing,
+		DiskMode:        backing.DiskMode,
+		ThinProvisioned: backing.ThinProvisioned,
+	}
+
+	return &disk
+}
+
+func (l VirtualDeviceList) connectivity(device types.BaseVirtualDevice, v bool) error {
+	c := device.GetVirtualDevice().Connectable
+	if c == nil {
+		return fmt.Errorf("%s is not connectable", l.Name(device))
+	}
+
+	c.Connected = v
+	c.StartConnected = v
+
+	return nil
+}
+
+// Connect changes the device to connected, returns an error if the device is not connectable.
+func (l VirtualDeviceList) Connect(device types.BaseVirtualDevice) error {
+	return l.connectivity(device, true)
+}
+
+// Disconnect changes the device to disconnected, returns an error if the device is not connectable.
+func (l VirtualDeviceList) Disconnect(device types.BaseVirtualDevice) error {
+	return l.connectivity(device, false)
+}
+
+// FindCdrom finds a cdrom device with the given name, defaulting to the first cdrom device if any.
+func (l VirtualDeviceList) FindCdrom(name string) (*types.VirtualCdrom, error) {
+	if name != "" {
+		d := l.Find(name)
+		if d == nil {
+			return nil, fmt.Errorf("device '%s' not found", name)
+		}
+		if c, ok := d.(*types.VirtualCdrom); ok {
+			return c, nil
+		}
+		return nil, fmt.Errorf("%s is not a cdrom device", name)
+	}
+
+	c := l.SelectByType((*types.VirtualCdrom)(nil))
+	if len(c) == 0 {
+		return nil, errors.New("no cdrom device found")
+	}
+
+	return c[0].(*types.VirtualCdrom), nil
+}
+
+// CreateCdrom creates a new VirtualCdrom device which can be added to a VM.
+func (l VirtualDeviceList) CreateCdrom(c *types.VirtualIDEController) (*types.VirtualCdrom, error) {
+	device := &types.VirtualCdrom{}
+
+	l.AssignController(device, c)
+
+	l.setDefaultCdromBacking(device)
+
+	device.Connectable = &types.VirtualDeviceConnectInfo{
+		AllowGuestControl: true,
+		Connected:         true,
+		StartConnected:    true,
+	}
+
+	return device, nil
+}
+
+// InsertIso changes the cdrom device backing to use the given iso file.
+func (l VirtualDeviceList) InsertIso(device *types.VirtualCdrom, iso string) *types.VirtualCdrom {
+	device.Backing = &types.VirtualCdromIsoBackingInfo{
+		VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+			FileName: iso,
+		},
+	}
+
+	return device
+}
+
+// EjectIso removes the iso file based backing and replaces with the default cdrom backing.
+func (l VirtualDeviceList) EjectIso(device *types.VirtualCdrom) *types.VirtualCdrom {
+	l.setDefaultCdromBacking(device)
+	return device
+}
+
+func (l VirtualDeviceList) setDefaultCdromBacking(device *types.VirtualCdrom) {
+	device.Backing = &types.VirtualCdromAtapiBackingInfo{
+		VirtualDeviceDeviceBackingInfo: types.VirtualDeviceDeviceBackingInfo{
+			DeviceName:    fmt.Sprintf("%s-%d-%d", DeviceTypeCdrom, device.ControllerKey, device.UnitNumber),
+			UseAutoDetect: types.NewBool(false),
+		},
+	}
+}
+
+// FindFloppy finds a floppy device with the given name, defaulting to the first floppy device if any.
+func (l VirtualDeviceList) FindFloppy(name string) (*types.VirtualFloppy, error) {
+	if name != "" {
+		d := l.Find(name)
+		if d == nil {
+			return nil, fmt.Errorf("device '%s' not found", name)
+		}
+		if c, ok := d.(*types.VirtualFloppy); ok {
+			return c, nil
+		}
+		return nil, fmt.Errorf("%s is not a floppy device", name)
+	}
+
+	c := l.SelectByType((*types.VirtualFloppy)(nil))
+	if len(c) == 0 {
+		return nil, errors.New("no floppy device found")
+	}
+
+	return c[0].(*types.VirtualFloppy), nil
+}
+
+// CreateFloppy creates a new VirtualFloppy device which can be added to a VM.
+func (l VirtualDeviceList) CreateFloppy() (*types.VirtualFloppy, error) {
+	device := &types.VirtualFloppy{}
+
+	c := l.PickController((*types.VirtualSIOController)(nil))
+	if c == nil {
+		return nil, errors.New("no available SIO controller")
+	}
+
+	l.AssignController(device, c)
+
+	l.setDefaultFloppyBacking(device)
+
+	device.Connectable = &types.VirtualDeviceConnectInfo{
+		AllowGuestControl: true,
+		Connected:         true,
+		StartConnected:    true,
+	}
+
+	return device, nil
+}
+
+// InsertImg changes the floppy device backing to use the given img file.
+func (l VirtualDeviceList) InsertImg(device *types.VirtualFloppy, img string) *types.VirtualFloppy {
+	device.Backing = &types.VirtualFloppyImageBackingInfo{
+		VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+			FileName: img,
+		},
+	}
+
+	return device
+}
+
+// EjectImg removes the img file based backing and replaces with the default floppy backing.
+func (l VirtualDeviceList) EjectImg(device *types.VirtualFloppy) *types.VirtualFloppy {
+	l.setDefaultFloppyBacking(device)
+	return device
+}
+
+func (l VirtualDeviceList) setDefaultFloppyBacking(device *types.VirtualFloppy) {
+	device.Backing = &types.VirtualFloppyDeviceBackingInfo{
+		VirtualDeviceDeviceBackingInfo: types.VirtualDeviceDeviceBackingInfo{
+			DeviceName:    fmt.Sprintf("%s-%d", DeviceTypeFloppy, device.UnitNumber),
+			UseAutoDetect: types.NewBool(false),
+		},
+	}
+}
+
+// FindSerialPort finds a serial port device with the given name, defaulting to the first serial port device if any.
+func (l VirtualDeviceList) FindSerialPort(name string) (*types.VirtualSerialPort, error) {
+	if name != "" {
+		d := l.Find(name)
+		if d == nil {
+			return nil, fmt.Errorf("device '%s' not found", name)
+		}
+		if c, ok := d.(*types.VirtualSerialPort); ok {
+			return c, nil
+		}
+		return nil, fmt.Errorf("%s is not a serial port device", name)
+	}
+
+	c := l.SelectByType((*types.VirtualSerialPort)(nil))
+	if len(c) == 0 {
+		return nil, errors.New("no serial port device found")
+	}
+
+	return c[0].(*types.VirtualSerialPort), nil
+}
+
+// CreateSerialPort creates a new VirtualSerialPort device which can be added to a VM.
+func (l VirtualDeviceList) CreateSerialPort() (*types.VirtualSerialPort, error) {
+	device := &types.VirtualSerialPort{
+		YieldOnPoll: true,
+	}
+
+	c := l.PickController((*types.VirtualSIOController)(nil))
+	if c == nil {
+		return nil, errors.New("no available SIO controller")
+	}
+
+	l.AssignController(device, c)
+
+	l.setDefaultSerialPortBacking(device)
+
+	return device, nil
+}
+
+// ConnectSerialPort connects a serial port to a server or client uri.
+func (l VirtualDeviceList) ConnectSerialPort(device *types.VirtualSerialPort, uri string, client bool, proxyuri string) *types.VirtualSerialPort {
+	if strings.HasPrefix(uri, "[") {
+		device.Backing = &types.VirtualSerialPortFileBackingInfo{
+			VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+				FileName: uri,
+			},
+		}
+
+		return device
+	}
+
+	direction := types.VirtualDeviceURIBackingOptionDirectionServer
+	if client {
+		direction = types.VirtualDeviceURIBackingOptionDirectionClient
+	}
+
+	device.Backing = &types.VirtualSerialPortURIBackingInfo{
+		VirtualDeviceURIBackingInfo: types.VirtualDeviceURIBackingInfo{
+			Direction:  string(direction),
+			ServiceURI: uri,
+			ProxyURI:   proxyuri,
+		},
+	}
+
+	return device
+}
+
+// DisconnectSerialPort disconnects the serial port backing.
+func (l VirtualDeviceList) DisconnectSerialPort(device *types.VirtualSerialPort) *types.VirtualSerialPort {
+	l.setDefaultSerialPortBacking(device)
+	return device
+}
+
+func (l VirtualDeviceList) setDefaultSerialPortBacking(device *types.VirtualSerialPort) {
+	device.Backing = &types.VirtualSerialPortURIBackingInfo{
+		VirtualDeviceURIBackingInfo: types.VirtualDeviceURIBackingInfo{
+			Direction:  "client",
+			ServiceURI: "localhost:0",
+		},
+	}
+}
+
+// CreateEthernetCard creates a new VirtualEthernetCard of the given name name and initialized with the given backing.
+func (l VirtualDeviceList) CreateEthernetCard(name string, backing types.BaseVirtualDeviceBackingInfo) (types.BaseVirtualDevice, error) {
+	ctypes := EthernetCardTypes()
+
+	if name == "" {
+		name = ctypes.deviceName(ctypes[0])
+	}
+
+	found := ctypes.Select(func(device types.BaseVirtualDevice) bool {
+		return l.deviceName(device) == name
+	})
+
+	if len(found) == 0 {
+		return nil, fmt.Errorf("unknown ethernet card type '%s'", name)
+	}
+
+	c, ok := found[0].(types.BaseVirtualEthernetCard)
+	if !ok {
+		return nil, fmt.Errorf("invalid ethernet card type '%s'", name)
+	}
+
+	c.GetVirtualEthernetCard().Backing = backing
+
+	return c.(types.BaseVirtualDevice), nil
+}
+
+// PrimaryMacAddress returns the MacAddress field of the primary VirtualEthernetCard
+func (l VirtualDeviceList) PrimaryMacAddress() string {
+	eth0 := l.Find("ethernet-0")
+
+	if eth0 == nil {
+		return ""
+	}
+
+	return eth0.(types.BaseVirtualEthernetCard).GetVirtualEthernetCard().MacAddress
+}
+
+// convert a BaseVirtualDevice to a BaseVirtualMachineBootOptionsBootableDevice
+var bootableDevices = map[string]func(device types.BaseVirtualDevice) types.BaseVirtualMachineBootOptionsBootableDevice{
+	DeviceTypeNone: func(types.BaseVirtualDevice) types.BaseVirtualMachineBootOptionsBootableDevice {
+		return &types.VirtualMachineBootOptionsBootableDevice{}
+	},
+	DeviceTypeCdrom: func(types.BaseVirtualDevice) types.BaseVirtualMachineBootOptionsBootableDevice {
+		return &types.VirtualMachineBootOptionsBootableCdromDevice{}
+	},
+	DeviceTypeDisk: func(d types.BaseVirtualDevice) types.BaseVirtualMachineBootOptionsBootableDevice {
+		return &types.VirtualMachineBootOptionsBootableDiskDevice{
+			DeviceKey: d.GetVirtualDevice().Key,
+		}
+	},
+	DeviceTypeEthernet: func(d types.BaseVirtualDevice) types.BaseVirtualMachineBootOptionsBootableDevice {
+		return &types.VirtualMachineBootOptionsBootableEthernetDevice{
+			DeviceKey: d.GetVirtualDevice().Key,
+		}
+	},
+	DeviceTypeFloppy: func(types.BaseVirtualDevice) types.BaseVirtualMachineBootOptionsBootableDevice {
+		return &types.VirtualMachineBootOptionsBootableFloppyDevice{}
+	},
+}
+
+// BootOrder returns a list of devices which can be used to set boot order via VirtualMachine.SetBootOptions.
+// The order can be any of "ethernet", "cdrom", "floppy" or "disk" or by specific device name.
+// A value of "-" will clear the existing boot order on the VC/ESX side.
+func (l VirtualDeviceList) BootOrder(order []string) []types.BaseVirtualMachineBootOptionsBootableDevice {
+	var devices []types.BaseVirtualMachineBootOptionsBootableDevice
+
+	for _, name := range order {
+		if kind, ok := bootableDevices[name]; ok {
+			if name == DeviceTypeNone {
+				// Not covered in the API docs, nor obvious, but this clears the boot order on the VC/ESX side.
+				devices = append(devices, new(types.VirtualMachineBootOptionsBootableDevice))
+				continue
+			}
+
+			for _, device := range l {
+				if l.Type(device) == name {
+					devices = append(devices, kind(device))
+				}
+			}
+			continue
+		}
+
+		if d := l.Find(name); d != nil {
+			if kind, ok := bootableDevices[l.Type(d)]; ok {
+				devices = append(devices, kind(d))
+			}
+		}
+	}
+
+	return devices
+}
+
+// SelectBootOrder returns an ordered list of devices matching the given bootable device order
+func (l VirtualDeviceList) SelectBootOrder(order []types.BaseVirtualMachineBootOptionsBootableDevice) VirtualDeviceList {
+	var devices VirtualDeviceList
+
+	for _, bd := range order {
+		for _, device := range l {
+			if kind, ok := bootableDevices[l.Type(device)]; ok {
+				if reflect.DeepEqual(kind(device), bd) {
+					devices = append(devices, device)
+				}
+			}
+		}
+	}
+
+	return devices
+}
+
+// TypeName returns the vmodl type name of the device
+func (l VirtualDeviceList) TypeName(device types.BaseVirtualDevice) string {
+	dtype := reflect.TypeOf(device)
+	if dtype == nil {
+		return ""
+	}
+	return dtype.Elem().Name()
+}
+
+var deviceNameRegexp = regexp.MustCompile(`(?:Virtual)?(?:Machine)?(\w+?)(?:Card|Device|Controller)?$`)
+
+func (l VirtualDeviceList) deviceName(device types.BaseVirtualDevice) string {
+	name := "device"
+	typeName := l.TypeName(device)
+
+	m := deviceNameRegexp.FindStringSubmatch(typeName)
+	if len(m) == 2 {
+		name = strings.ToLower(m[1])
+	}
+
+	return name
+}
+
+// Type returns a human-readable name for the given device
+func (l VirtualDeviceList) Type(device types.BaseVirtualDevice) string {
+	switch device.(type) {
+	case types.BaseVirtualEthernetCard:
+		return DeviceTypeEthernet
+	case *types.ParaVirtualSCSIController:
+		return "pvscsi"
+	case *types.VirtualLsiLogicSASController:
+		return "lsilogic-sas"
+	case *types.VirtualNVMEController:
+		return "nvme"
+	default:
+		return l.deviceName(device)
+	}
+}
+
+// Name returns a stable, human-readable name for the given device
+func (l VirtualDeviceList) Name(device types.BaseVirtualDevice) string {
+	var key string
+	var UnitNumber int32
+	d := device.GetVirtualDevice()
+	if d.UnitNumber != nil {
+		UnitNumber = *d.UnitNumber
+	}
+
+	dtype := l.Type(device)
+	switch dtype {
+	case DeviceTypeEthernet:
+		key = fmt.Sprintf("%d", UnitNumber-7)
+	case DeviceTypeDisk:
+		key = fmt.Sprintf("%d-%d", d.ControllerKey, UnitNumber)
+	default:
+		key = fmt.Sprintf("%d", d.Key)
+	}
+
+	return fmt.Sprintf("%s-%s", dtype, key)
+}
+
+// ConfigSpec creates a virtual machine configuration spec for
+// the specified operation, for the list of devices in the device list.
+func (l VirtualDeviceList) ConfigSpec(op types.VirtualDeviceConfigSpecOperation) ([]types.BaseVirtualDeviceConfigSpec, error) {
+	var fop types.VirtualDeviceConfigSpecFileOperation
+	switch op {
+	case types.VirtualDeviceConfigSpecOperationAdd:
+		fop = types.VirtualDeviceConfigSpecFileOperationCreate
+	case types.VirtualDeviceConfigSpecOperationEdit:
+		fop = types.VirtualDeviceConfigSpecFileOperationReplace
+	case types.VirtualDeviceConfigSpecOperationRemove:
+		fop = types.VirtualDeviceConfigSpecFileOperationDestroy
+	default:
+		panic("unknown op")
+	}
+
+	var res []types.BaseVirtualDeviceConfigSpec
+	for _, device := range l {
+		config := &types.VirtualDeviceConfigSpec{
+			Device:    device,
+			Operation: op,
+		}
+
+		if disk, ok := device.(*types.VirtualDisk); ok {
+			config.FileOperation = fop
+
+			// Special case to attach an existing disk
+			if op == types.VirtualDeviceConfigSpecOperationAdd && disk.CapacityInKB == 0 {
+				childDisk := false
+				if b, ok := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo); ok {
+					childDisk = b.Parent != nil
+				}
+
+				if !childDisk {
+					// Existing disk, clear file operation
+					config.FileOperation = ""
+				}
+			}
+		}
+
+		res = append(res, config)
+	}
+
+	return res, nil
+}

vendor/github.com/vmware/govmomi/object/virtual_device_list_test.go

@@ -0,0 +1,877 @@
+/*
+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 object
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+func intPtrValue(val int32) *int32 {
+	return &val
+}
+
+var devices = VirtualDeviceList([]types.BaseVirtualDevice{
+	&types.VirtualIDEController{
+		VirtualController: types.VirtualController{
+			VirtualDevice: types.VirtualDevice{
+				DynamicData: types.DynamicData{},
+				Key:         200,
+				DeviceInfo: &types.Description{
+					DynamicData: types.DynamicData{},
+					Label:       "IDE 0",
+					Summary:     "IDE 0",
+				},
+				Backing:       nil,
+				Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+				SlotInfo:      nil,
+				ControllerKey: 0,
+				UnitNumber:    intPtrValue(0),
+			},
+			BusNumber: 0,
+			Device:    []int32{3001, 3000},
+		},
+	},
+	&types.VirtualIDEController{
+		VirtualController: types.VirtualController{
+			VirtualDevice: types.VirtualDevice{
+				DynamicData: types.DynamicData{},
+				Key:         201,
+				DeviceInfo: &types.Description{
+					DynamicData: types.DynamicData{},
+					Label:       "IDE 1",
+					Summary:     "IDE 1",
+				},
+				Backing:       nil,
+				Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+				SlotInfo:      nil,
+				ControllerKey: 0,
+				UnitNumber:    intPtrValue(0),
+			},
+			BusNumber: 1,
+			Device:    []int32{3002},
+		},
+	},
+	&types.VirtualPS2Controller{
+		VirtualController: types.VirtualController{
+			VirtualDevice: types.VirtualDevice{
+				DynamicData: types.DynamicData{},
+				Key:         300,
+				DeviceInfo: &types.Description{
+					DynamicData: types.DynamicData{},
+					Label:       "PS2 controller 0",
+					Summary:     "PS2 controller 0",
+				},
+				Backing:       nil,
+				Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+				SlotInfo:      nil,
+				ControllerKey: 0,
+				UnitNumber:    intPtrValue(0),
+			},
+			BusNumber: 0,
+			Device:    []int32{600, 700},
+		},
+	},
+	&types.VirtualPCIController{
+		VirtualController: types.VirtualController{
+			VirtualDevice: types.VirtualDevice{
+				DynamicData: types.DynamicData{},
+				Key:         100,
+				DeviceInfo: &types.Description{
+					DynamicData: types.DynamicData{},
+					Label:       "PCI controller 0",
+					Summary:     "PCI controller 0",
+				},
+				Backing:       nil,
+				Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+				SlotInfo:      nil,
+				ControllerKey: 0,
+				UnitNumber:    intPtrValue(0),
+			},
+			BusNumber: 0,
+			Device:    []int32{500, 12000, 1000, 4000},
+		},
+	},
+	&types.VirtualSIOController{
+		VirtualController: types.VirtualController{
+			VirtualDevice: types.VirtualDevice{
+				DynamicData: types.DynamicData{},
+				Key:         400,
+				DeviceInfo: &types.Description{
+					DynamicData: types.DynamicData{},
+					Label:       "SIO controller 0",
+					Summary:     "SIO controller 0",
+				},
+				Backing:       nil,
+				Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+				SlotInfo:      nil,
+				ControllerKey: 0,
+				UnitNumber:    intPtrValue(0),
+			},
+			BusNumber: 0,
+			Device:    []int32{9000},
+		},
+	},
+	&types.VirtualKeyboard{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         600,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "Keyboard ",
+				Summary:     "Keyboard",
+			},
+			Backing:       nil,
+			Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+			SlotInfo:      nil,
+			ControllerKey: 300,
+			UnitNumber:    intPtrValue(0),
+		},
+	},
+	&types.VirtualPointingDevice{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         700,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "Pointing device",
+				Summary:     "Pointing device; Device",
+			},
+			Backing: &types.VirtualPointingDeviceDeviceBackingInfo{
+				VirtualDeviceDeviceBackingInfo: types.VirtualDeviceDeviceBackingInfo{},
+				HostPointingDevice:             "autodetect",
+			},
+			Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+			SlotInfo:      nil,
+			ControllerKey: 300,
+			UnitNumber:    intPtrValue(1),
+		},
+	},
+	&types.VirtualMachineVideoCard{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         500,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "Video card ",
+				Summary:     "Video card",
+			},
+			Backing:       nil,
+			Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+			SlotInfo:      nil,
+			ControllerKey: 100,
+			UnitNumber:    intPtrValue(0),
+		},
+		VideoRamSizeInKB: 4096,
+		NumDisplays:      1,
+		UseAutoDetect:    types.NewBool(false),
+		Enable3DSupport:  types.NewBool(false),
+		Use3dRenderer:    "automatic",
+	},
+	&types.VirtualMachineVMCIDevice{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         12000,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "VMCI device",
+				Summary:     "Device on the virtual machine PCI bus that provides support for the virtual machine communication interface",
+			},
+			Backing:     nil,
+			Connectable: (*types.VirtualDeviceConnectInfo)(nil),
+			SlotInfo: &types.VirtualDevicePciBusSlotInfo{
+				VirtualDeviceBusSlotInfo: types.VirtualDeviceBusSlotInfo{},
+				PciSlotNumber:            33,
+			},
+			ControllerKey: 100,
+			UnitNumber:    intPtrValue(17),
+		},
+		Id: 1754519335,
+		AllowUnrestrictedCommunication: types.NewBool(false),
+	},
+	&types.VirtualLsiLogicController{
+		VirtualSCSIController: types.VirtualSCSIController{
+			VirtualController: types.VirtualController{
+				VirtualDevice: types.VirtualDevice{
+					DynamicData: types.DynamicData{},
+					Key:         1000,
+					DeviceInfo: &types.Description{
+						DynamicData: types.DynamicData{},
+						Label:       "SCSI controller 0",
+						Summary:     "LSI Logic",
+					},
+					Backing:       nil,
+					Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+					SlotInfo:      nil,
+					ControllerKey: 100,
+					UnitNumber:    intPtrValue(3),
+				},
+				BusNumber: 0,
+				Device:    nil,
+			},
+			HotAddRemove:       types.NewBool(true),
+			SharedBus:          "noSharing",
+			ScsiCtlrUnitNumber: 7,
+		},
+	},
+	&types.VirtualCdrom{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         3001,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "CD/DVD drive 1",
+				Summary:     "ISO [datastore1] ttylinux-pc_i486-16.1.iso",
+			},
+			Backing: &types.VirtualCdromIsoBackingInfo{
+				VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+					VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+					FileName:                 "[datastore1] foo.iso",
+					Datastore:                &types.ManagedObjectReference{Type: "Datastore", Value: "53fe43cc-75dc5110-3643-000c2918dc41"},
+					BackingObjectId:          "",
+				},
+			},
+			Connectable: &types.VirtualDeviceConnectInfo{
+				DynamicData:       types.DynamicData{},
+				StartConnected:    true,
+				AllowGuestControl: true,
+				Connected:         false,
+				Status:            "untried",
+			},
+			SlotInfo:      nil,
+			ControllerKey: 200,
+			UnitNumber:    intPtrValue(1),
+		},
+	},
+	&types.VirtualDisk{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         3000,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "Hard disk 1",
+				Summary:     "30,720 KB",
+			},
+			Backing: &types.VirtualDiskFlatVer2BackingInfo{
+				VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+					VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+					FileName:                 "[datastore1] bar/bar.vmdk",
+					Datastore:                &types.ManagedObjectReference{Type: "Datastore", Value: "53fe43cc-75dc5110-3643-000c2918dc41"},
+					BackingObjectId:          "3-3000-0",
+				},
+				DiskMode:        "persistent",
+				Split:           types.NewBool(false),
+				WriteThrough:    types.NewBool(false),
+				ThinProvisioned: types.NewBool(false),
+				EagerlyScrub:    types.NewBool(true),
+				Uuid:            "6000C296-d0af-1209-1975-10c98eae10e4",
+				ContentId:       "d46395062e2d1b1790985bdec573b211",
+				ChangeId:        "",
+				Parent: &types.VirtualDiskFlatVer2BackingInfo{
+					VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+						VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+						FileName:                 "[datastore1] ttylinux.vmdk",
+						Datastore:                &types.ManagedObjectReference{Type: "Datastore", Value: "53fe43cc-75dc5110-3643-000c2918dc41"},
+						BackingObjectId:          "3-3000-1",
+					},
+					DiskMode:        "persistent",
+					Split:           types.NewBool(false),
+					WriteThrough:    types.NewBool(false),
+					ThinProvisioned: types.NewBool(false),
+					EagerlyScrub:    types.NewBool(true),
+					Uuid:            "6000C296-d0af-1209-1975-10c98eae10e4",
+					ContentId:       "1c2dad9e1662219e962a620c6d238a7c",
+					ChangeId:        "",
+					Parent:          (*types.VirtualDiskFlatVer2BackingInfo)(nil),
+					DeltaDiskFormat: "",
+					DigestEnabled:   types.NewBool(false),
+					DeltaGrainSize:  0,
+				},
+				DeltaDiskFormat: "redoLogFormat",
+				DigestEnabled:   types.NewBool(false),
+				DeltaGrainSize:  0,
+			},
+			Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+			SlotInfo:      nil,
+			ControllerKey: 200,
+			UnitNumber:    intPtrValue(0),
+		},
+		CapacityInKB:    30720,
+		CapacityInBytes: 31457280,
+		Shares: &types.SharesInfo{
+			DynamicData: types.DynamicData{},
+			Shares:      1000,
+			Level:       "normal",
+		},
+		StorageIOAllocation: &types.StorageIOAllocationInfo{
+			DynamicData: types.DynamicData{},
+			Limit:       types.NewInt64(-1),
+			Shares: &types.SharesInfo{
+				DynamicData: types.DynamicData{},
+				Shares:      1000,
+				Level:       "normal",
+			},
+			Reservation: types.NewInt32(0),
+		},
+		DiskObjectId:          "3-3000",
+		VFlashCacheConfigInfo: (*types.VirtualDiskVFlashCacheConfigInfo)(nil),
+	},
+	&types.VirtualDisk{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         3002,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "Hard disk 2",
+				Summary:     "10,000,000 KB",
+			},
+			Backing: &types.VirtualDiskFlatVer2BackingInfo{
+				VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+					VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+					FileName:                 "[datastore1] bar/disk-201-0.vmdk",
+					Datastore:                &types.ManagedObjectReference{Type: "Datastore", Value: "53fe43cc-75dc5110-3643-000c2918dc41"},
+					BackingObjectId:          "3-3002-0",
+				},
+				DiskMode:        "persistent",
+				Split:           types.NewBool(false),
+				WriteThrough:    types.NewBool(false),
+				ThinProvisioned: types.NewBool(true),
+				EagerlyScrub:    types.NewBool(false),
+				Uuid:            "6000C293-fde5-4457-5118-dd267ea992a7",
+				ContentId:       "90399989b9d520eed6793ab0fffffffe",
+				ChangeId:        "",
+				Parent:          (*types.VirtualDiskFlatVer2BackingInfo)(nil),
+				DeltaDiskFormat: "",
+				DigestEnabled:   types.NewBool(false),
+				DeltaGrainSize:  0,
+			},
+			Connectable:   (*types.VirtualDeviceConnectInfo)(nil),
+			SlotInfo:      nil,
+			ControllerKey: 201,
+			UnitNumber:    intPtrValue(0),
+		},
+		CapacityInKB:    10000000,
+		CapacityInBytes: 10240000000,
+		Shares: &types.SharesInfo{
+			DynamicData: types.DynamicData{},
+			Shares:      1000,
+			Level:       "normal",
+		},
+		StorageIOAllocation: &types.StorageIOAllocationInfo{
+			DynamicData: types.DynamicData{},
+			Limit:       types.NewInt64(-1),
+			Shares: &types.SharesInfo{
+				DynamicData: types.DynamicData{},
+				Shares:      1000,
+				Level:       "normal",
+			},
+			Reservation: types.NewInt32(0),
+		},
+		DiskObjectId:          "3-3002",
+		VFlashCacheConfigInfo: (*types.VirtualDiskVFlashCacheConfigInfo)(nil),
+	},
+	&types.VirtualE1000{
+		VirtualEthernetCard: types.VirtualEthernetCard{
+			VirtualDevice: types.VirtualDevice{
+				DynamicData: types.DynamicData{},
+				Key:         4000,
+				DeviceInfo: &types.Description{
+					DynamicData: types.DynamicData{},
+					Label:       "Network adapter 1",
+					Summary:     "VM Network",
+				},
+				Backing: &types.VirtualEthernetCardNetworkBackingInfo{
+					VirtualDeviceDeviceBackingInfo: types.VirtualDeviceDeviceBackingInfo{
+						VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+						DeviceName:               "VM Network",
+						UseAutoDetect:            types.NewBool(false),
+					},
+					Network:           &types.ManagedObjectReference{Type: "Network", Value: "HaNetwork-VM Network"},
+					InPassthroughMode: types.NewBool(false),
+				},
+				Connectable: &types.VirtualDeviceConnectInfo{
+					DynamicData:       types.DynamicData{},
+					StartConnected:    true,
+					AllowGuestControl: true,
+					Connected:         false,
+					Status:            "untried",
+				},
+				SlotInfo: &types.VirtualDevicePciBusSlotInfo{
+					VirtualDeviceBusSlotInfo: types.VirtualDeviceBusSlotInfo{},
+					PciSlotNumber:            32,
+				},
+				ControllerKey: 100,
+				UnitNumber:    intPtrValue(7),
+			},
+			AddressType:      "generated",
+			MacAddress:       "00:0c:29:93:d7:27",
+			WakeOnLanEnabled: types.NewBool(true),
+		},
+	},
+	&types.VirtualSerialPort{
+		VirtualDevice: types.VirtualDevice{
+			DynamicData: types.DynamicData{},
+			Key:         9000,
+			DeviceInfo: &types.Description{
+				DynamicData: types.DynamicData{},
+				Label:       "Serial port 1",
+				Summary:     "Remote localhost:0",
+			},
+			Backing: &types.VirtualSerialPortURIBackingInfo{
+				VirtualDeviceURIBackingInfo: types.VirtualDeviceURIBackingInfo{
+					VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+					ServiceURI:               "localhost:0",
+					Direction:                "client",
+					ProxyURI:                 "",
+				},
+			},
+			Connectable: &types.VirtualDeviceConnectInfo{
+				DynamicData:       types.DynamicData{},
+				StartConnected:    true,
+				AllowGuestControl: true,
+				Connected:         false,
+				Status:            "untried",
+			},
+			SlotInfo:      nil,
+			ControllerKey: 400,
+			UnitNumber:    intPtrValue(0),
+		},
+		YieldOnPoll: true,
+	},
+})
+
+func TestSelectByType(t *testing.T) {
+	tests := []struct {
+		dtype  types.BaseVirtualDevice
+		expect int
+	}{
+		{
+			(*types.VirtualCdrom)(nil),
+			1,
+		},
+		{
+			(*types.VirtualEthernetCard)(nil),
+			1,
+		},
+		{
+			(*types.VirtualDisk)(nil),
+			2,
+		},
+		{
+			(*types.VirtualController)(nil),
+			6,
+		},
+		{
+			(*types.VirtualIDEController)(nil),
+			2,
+		},
+		{
+			(*types.VirtualSCSIController)(nil),
+			1,
+		},
+		{
+			(*types.VirtualLsiLogicController)(nil),
+			1,
+		},
+		{
+			(*types.ParaVirtualSCSIController)(nil),
+			0,
+		},
+	}
+
+	for _, test := range tests {
+		d := devices.SelectByType(test.dtype)
+
+		if len(d) != test.expect {
+			t.Errorf("%#v has %d", test.dtype, len(devices))
+		}
+	}
+}
+
+func TestSelectByBackingInfo(t *testing.T) {
+	tests := []types.BaseVirtualDeviceBackingInfo{
+		&types.VirtualEthernetCardNetworkBackingInfo{
+			VirtualDeviceDeviceBackingInfo: types.VirtualDeviceDeviceBackingInfo{
+				DeviceName: "VM Network",
+			},
+		},
+		&types.VirtualDiskFlatVer2BackingInfo{
+			VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+				FileName: "[datastore1] bar/bar.vmdk",
+			},
+		},
+		&types.VirtualDiskFlatVer2BackingInfo{
+			Parent: &types.VirtualDiskFlatVer2BackingInfo{
+				VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+					FileName: "[datastore1] ttylinux.vmdk",
+				},
+			},
+		},
+		&types.VirtualCdromIsoBackingInfo{
+			VirtualDeviceFileBackingInfo: types.VirtualDeviceFileBackingInfo{
+				VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+				FileName:                 "[datastore1] foo.iso",
+			},
+		},
+		(*types.VirtualCdromIsoBackingInfo)(nil),
+		&types.VirtualSerialPortURIBackingInfo{
+			VirtualDeviceURIBackingInfo: types.VirtualDeviceURIBackingInfo{
+				VirtualDeviceBackingInfo: types.VirtualDeviceBackingInfo{},
+				ServiceURI:               "localhost:0",
+				Direction:                "client",
+				ProxyURI:                 "",
+			},
+		},
+		(*types.VirtualSerialPortURIBackingInfo)(nil),
+	}
+
+	for _, test := range tests {
+		l := devices.SelectByBackingInfo(test)
+
+		if len(l) != 1 {
+			t.Errorf("Expected 1, got %d: %#v", len(l), test)
+		}
+	}
+
+	// test selecting by backing type
+	tests = []types.BaseVirtualDeviceBackingInfo{
+		(*types.VirtualDiskFlatVer2BackingInfo)(nil),
+	}
+
+	for _, test := range tests {
+		l := devices.SelectByBackingInfo(test)
+
+		if len(l) != 2 {
+			t.Errorf("Expected 2, got %d: %#v", len(l), test)
+		}
+	}
+}
+
+func TestFind(t *testing.T) {
+	for _, device := range devices {
+		name := devices.Name(device)
+		d := devices.Find(name)
+		if name != devices.Name(d) {
+			t.Errorf("expected name: %s, got: %s", name, devices.Name(d))
+		}
+	}
+
+	d := devices.Find("enoent")
+	if d != nil {
+		t.Errorf("unexpected: %#v", d)
+	}
+}
+
+func TestFindController(t *testing.T) {
+	for _, name := range []string{"", "ide-200"} {
+		_, err := devices.FindIDEController(name)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	for _, name := range []string{"", "lsilogic-1000"} {
+		_, err := devices.FindSCSIController(name)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	fns := []func() error{
+		func() error {
+			_, err := devices.FindIDEController("lsilogic-1000")
+			return err
+		},
+		func() error {
+			_, err := devices.FindSCSIController("ide-200")
+			return err
+		},
+	}
+
+	for _, f := range fns {
+		err := f()
+		if err == nil {
+			t.Error("should fail")
+		}
+	}
+}
+
+func TestPickController(t *testing.T) {
+	list := devices
+
+	tests := []struct {
+		ctype types.BaseVirtualController
+		key   int32
+		unit  int32
+	}{
+		{
+			(*types.VirtualIDEController)(nil), 201, 1,
+		},
+		{
+			(*types.VirtualSCSIController)(nil), 1000, 0,
+		},
+		{
+			(*types.VirtualSCSIController)(nil), 1000, 1,
+		},
+	}
+
+	for _, test := range tests {
+		c := list.PickController(test.ctype).GetVirtualController()
+
+		key := c.Key
+		if key != test.key {
+			t.Errorf("expected controller key: %d, got: %d\n", test.key, key)
+		}
+
+		unit := list.newUnitNumber(c)
+		if unit != test.unit {
+			t.Errorf("expected unit number: %d, got: %d\n", test.unit, unit)
+		}
+
+		dev := &types.VirtualDevice{
+			Key:           int32(rand.Int()),
+			UnitNumber:    new(int32),
+			ControllerKey: key,
+		}
+		*dev.UnitNumber = unit
+
+		list = append(list, dev)
+		c.Device = append(c.Device, dev.Key)
+	}
+
+	if list.PickController((*types.VirtualIDEController)(nil)) != nil {
+		t.Error("should be nil")
+	}
+
+	if list.PickController((*types.VirtualSCSIController)(nil)) == nil {
+		t.Errorf("should not be nil")
+	}
+}
+
+func TestCreateSCSIController(t *testing.T) {
+	for _, l := range []VirtualDeviceList{SCSIControllerTypes(), devices} {
+		_, err := l.CreateSCSIController("enoent")
+		if err == nil {
+			t.Error("should fail")
+		}
+
+		for _, name := range []string{"", "scsi", "pvscsi", "buslogic", "lsilogic", "lsilogic-sas"} {
+			_, err = l.CreateSCSIController(name)
+			if err != nil {
+				t.Error(err)
+			}
+		}
+	}
+}
+
+func TestCreateEthernetCard(t *testing.T) {
+	_, err := EthernetCardTypes().CreateEthernetCard("enoent", nil)
+	if err == nil {
+		t.Error("should fail")
+	}
+
+	for _, name := range []string{"", "e1000", "e1000e", "vmxnet3"} {
+		_, err := EthernetCardTypes().CreateEthernetCard(name, nil)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+}
+
+func TestCdrom(t *testing.T) {
+	c, err := devices.FindCdrom("")
+	if err != nil {
+		t.Error(err)
+	}
+
+	d := devices.Find(devices.Name(c))
+
+	if c.Key != d.GetVirtualDevice().Key {
+		t.Error("device key mismatch")
+	}
+
+	for _, name := range []string{"enoent", "ide-200"} {
+		c, err = devices.FindCdrom(name)
+		if err == nil {
+			t.Errorf("FindCdrom(%s) should fail", name)
+		}
+	}
+
+	c, err = devices.Select(func(device types.BaseVirtualDevice) bool {
+		if _, ok := device.(*types.VirtualCdrom); ok {
+			return false
+		}
+		return true
+	}).FindCdrom("")
+
+	if err == nil {
+		t.Error("FindCdrom('') should fail")
+	}
+}
+
+func TestSerialPort(t *testing.T) {
+	device, err := devices.CreateSerialPort()
+	if err != nil {
+		t.Error(err)
+	}
+	devices.ConnectSerialPort(device, "telnet://:33233", false, "")
+}
+
+func TestPrimaryMacAddress(t *testing.T) {
+	expect := "00:0c:29:93:d7:27"
+	mac := devices.PrimaryMacAddress()
+	if expect != mac {
+		t.Errorf("expected: %s, got: %s", expect, mac)
+	}
+}
+
+func TestBootOrder(t *testing.T) {
+	o := []string{DeviceTypeEthernet, DeviceTypeCdrom, DeviceTypeFloppy, DeviceTypeDisk}
+	list := devices
+
+	n := 4 // 1 ethernet, 1 cdrom, 2 disk
+	order := list.BootOrder(o)
+	if len(order) != n {
+		t.Errorf("expected %d boot devices, got: %d", n, len(order))
+	}
+
+	list = list.SelectBootOrder(order)
+	if len(list) != n {
+		t.Errorf("expected %d boot devices, got: %d", n, len(list))
+	}
+
+	// test lookup by name
+	var names []string
+	for _, x := range list {
+		names = append(names, list.Name(x))
+	}
+
+	order = list.BootOrder(names)
+	if len(order) != n {
+		t.Errorf("expected %d boot devices, got: %d", n, len(order))
+	}
+
+	if !reflect.DeepEqual(list, list.SelectBootOrder(order)) {
+		t.Error("boot order mismatch")
+	}
+
+	// remove disks
+	list = list.Select(func(device types.BaseVirtualDevice) bool {
+		if _, ok := device.(*types.VirtualDisk); ok {
+			return false
+		}
+		return true
+	})
+
+	n = 2 // 1 ethernet, 1 cdrom
+	order = list.BootOrder(o)
+	if len(order) != n {
+		t.Errorf("expected %d boot devices, got: %d", n, len(order))
+	}
+
+	if !reflect.DeepEqual(list, list.SelectBootOrder(order)) {
+		t.Error("boot order mismatch")
+	}
+
+	if len(list.BootOrder([]string{DeviceTypeDisk})) != 0 {
+		t.Error("expected 0 disks")
+	}
+
+	if len(list.BootOrder([]string{DeviceTypeNone})) != 1 {
+		t.Error("expected 1")
+	}
+}
+
+func TestName(t *testing.T) {
+	tests := []struct {
+		device types.BaseVirtualDevice
+		expect string
+	}{
+		{
+			&types.VirtualCdrom{},
+			"cdrom-0",
+		},
+		{
+			&types.VirtualDisk{},
+			"disk-0-0",
+		},
+		{
+			&types.VirtualFloppy{},
+			"floppy-0",
+		},
+		{
+			&types.VirtualIDEController{},
+			"ide-0",
+		},
+		{
+			&types.VirtualMachineVideoCard{},
+			"video-0",
+		},
+		{
+			&types.VirtualPointingDevice{},
+			"pointing-0",
+		},
+		{
+			&types.ParaVirtualSCSIController{},
+			"pvscsi-0",
+		},
+		{
+			&types.VirtualSerialPort{},
+			"serialport-0",
+		},
+		{
+			&types.VirtualE1000{
+				VirtualEthernetCard: types.VirtualEthernetCard{
+					VirtualDevice: types.VirtualDevice{
+						UnitNumber: intPtrValue(7),
+					},
+				},
+			},
+			"ethernet-0",
+		},
+	}
+
+	for _, test := range tests {
+		name := devices.Name(test.device)
+		if name != test.expect {
+			t.Errorf("expected: %s, got: %s", test.expect, name)
+		}
+	}
+}
+
+func TestChildDisk(t *testing.T) {
+	disks := devices.SelectByType((*types.VirtualDisk)(nil))
+
+	for _, disk := range disks {
+		child := disks.ChildDisk(disk.(*types.VirtualDisk))
+		name := child.Backing.(*types.VirtualDiskFlatVer2BackingInfo).VirtualDeviceFileBackingInfo.FileName
+
+		p := new(DatastorePath)
+		p.FromString(name)
+
+		if p.Datastore != "datastore1" {
+			t.Fatal(p.Datastore)
+		}
+
+		if p.Path != "" {
+			t.Fatal(p.Path)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/object/virtual_disk_manager.go

@@ -0,0 +1,211 @@
+/*
+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 object
+
+import (
+	"context"
+
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type VirtualDiskManager struct {
+	Common
+}
+
+func NewVirtualDiskManager(c *vim25.Client) *VirtualDiskManager {
+	m := VirtualDiskManager{
+		Common: NewCommon(c, *c.ServiceContent.VirtualDiskManager),
+	}
+
+	return &m
+}
+
+// CopyVirtualDisk copies a virtual disk, performing conversions as specified in the spec.
+func (m VirtualDiskManager) CopyVirtualDisk(
+	ctx context.Context,
+	sourceName string, sourceDatacenter *Datacenter,
+	destName string, destDatacenter *Datacenter,
+	destSpec *types.VirtualDiskSpec, force bool) (*Task, error) {
+
+	req := types.CopyVirtualDisk_Task{
+		This:       m.Reference(),
+		SourceName: sourceName,
+		DestName:   destName,
+		DestSpec:   destSpec,
+		Force:      types.NewBool(force),
+	}
+
+	if sourceDatacenter != nil {
+		ref := sourceDatacenter.Reference()
+		req.SourceDatacenter = &ref
+	}
+
+	if destDatacenter != nil {
+		ref := destDatacenter.Reference()
+		req.DestDatacenter = &ref
+	}
+
+	res, err := methods.CopyVirtualDisk_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+// CreateVirtualDisk creates a new virtual disk.
+func (m VirtualDiskManager) CreateVirtualDisk(
+	ctx context.Context,
+	name string, datacenter *Datacenter,
+	spec types.BaseVirtualDiskSpec) (*Task, error) {
+
+	req := types.CreateVirtualDisk_Task{
+		This: m.Reference(),
+		Name: name,
+		Spec: spec,
+	}
+
+	if datacenter != nil {
+		ref := datacenter.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.CreateVirtualDisk_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+// MoveVirtualDisk moves a virtual disk.
+func (m VirtualDiskManager) MoveVirtualDisk(
+	ctx context.Context,
+	sourceName string, sourceDatacenter *Datacenter,
+	destName string, destDatacenter *Datacenter,
+	force bool) (*Task, error) {
+	req := types.MoveVirtualDisk_Task{
+		This:       m.Reference(),
+		SourceName: sourceName,
+		DestName:   destName,
+		Force:      types.NewBool(force),
+	}
+
+	if sourceDatacenter != nil {
+		ref := sourceDatacenter.Reference()
+		req.SourceDatacenter = &ref
+	}
+
+	if destDatacenter != nil {
+		ref := destDatacenter.Reference()
+		req.DestDatacenter = &ref
+	}
+
+	res, err := methods.MoveVirtualDisk_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+// DeleteVirtualDisk deletes a virtual disk.
+func (m VirtualDiskManager) DeleteVirtualDisk(ctx context.Context, name string, dc *Datacenter) (*Task, error) {
+	req := types.DeleteVirtualDisk_Task{
+		This: m.Reference(),
+		Name: name,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.DeleteVirtualDisk_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+// InflateVirtualDisk inflates a virtual disk.
+func (m VirtualDiskManager) InflateVirtualDisk(ctx context.Context, name string, dc *Datacenter) (*Task, error) {
+	req := types.InflateVirtualDisk_Task{
+		This: m.Reference(),
+		Name: name,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.InflateVirtualDisk_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+// ShrinkVirtualDisk shrinks a virtual disk.
+func (m VirtualDiskManager) ShrinkVirtualDisk(ctx context.Context, name string, dc *Datacenter, copy *bool) (*Task, error) {
+	req := types.ShrinkVirtualDisk_Task{
+		This: m.Reference(),
+		Name: name,
+		Copy: copy,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.ShrinkVirtualDisk_Task(ctx, m.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.c, res.Returnval), nil
+}
+
+// Queries virtual disk uuid
+func (m VirtualDiskManager) QueryVirtualDiskUuid(ctx context.Context, name string, dc *Datacenter) (string, error) {
+	req := types.QueryVirtualDiskUuid{
+		This: m.Reference(),
+		Name: name,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := methods.QueryVirtualDiskUuid(ctx, m.c, &req)
+	if err != nil {
+		return "", err
+	}
+
+	if res == nil {
+		return "", nil
+	}
+
+	return res.Returnval, nil
+}

vendor/github.com/vmware/govmomi/object/virtual_disk_manager_internal.go

@@ -0,0 +1,166 @@
+/*
+Copyright (c) 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 object
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+func init() {
+	types.Add("ArrayOfVirtualDiskInfo", reflect.TypeOf((*arrayOfVirtualDiskInfo)(nil)).Elem())
+
+	types.Add("VirtualDiskInfo", reflect.TypeOf((*VirtualDiskInfo)(nil)).Elem())
+}
+
+type arrayOfVirtualDiskInfo struct {
+	VirtualDiskInfo []VirtualDiskInfo `xml:"VirtualDiskInfo,omitempty"`
+}
+
+type queryVirtualDiskInfoTaskRequest struct {
+	This           types.ManagedObjectReference  `xml:"_this"`
+	Name           string                        `xml:"name"`
+	Datacenter     *types.ManagedObjectReference `xml:"datacenter,omitempty"`
+	IncludeParents bool                          `xml:"includeParents"`
+}
+
+type queryVirtualDiskInfoTaskResponse struct {
+	Returnval types.ManagedObjectReference `xml:"returnval"`
+}
+
+type queryVirtualDiskInfoTaskBody struct {
+	Req         *queryVirtualDiskInfoTaskRequest  `xml:"urn:internalvim25 QueryVirtualDiskInfo_Task,omitempty"`
+	Res         *queryVirtualDiskInfoTaskResponse `xml:"urn:vim25 QueryVirtualDiskInfo_TaskResponse,omitempty"`
+	InternalRes *queryVirtualDiskInfoTaskResponse `xml:"urn:internalvim25 QueryVirtualDiskInfo_TaskResponse,omitempty"`
+	Err         *soap.Fault                       `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
+}
+
+func (b *queryVirtualDiskInfoTaskBody) Fault() *soap.Fault { return b.Err }
+
+func queryVirtualDiskInfoTask(ctx context.Context, r soap.RoundTripper, req *queryVirtualDiskInfoTaskRequest) (*queryVirtualDiskInfoTaskResponse, error) {
+	var reqBody, resBody queryVirtualDiskInfoTaskBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	if resBody.Res != nil {
+		return resBody.Res, nil
+	}
+
+	return resBody.InternalRes, nil
+}
+
+type VirtualDiskInfo struct {
+	Name     string `xml:"unit>name"`
+	DiskType string `xml:"diskType"`
+	Parent   string `xml:"parent,omitempty"`
+}
+
+func (m VirtualDiskManager) QueryVirtualDiskInfo(ctx context.Context, name string, dc *Datacenter, includeParents bool) ([]VirtualDiskInfo, error) {
+	req := queryVirtualDiskInfoTaskRequest{
+		This:           m.Reference(),
+		Name:           name,
+		IncludeParents: includeParents,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.Datacenter = &ref
+	}
+
+	res, err := queryVirtualDiskInfoTask(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := NewTask(m.Client(), res.Returnval).WaitForResult(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return info.Result.(arrayOfVirtualDiskInfo).VirtualDiskInfo, nil
+}
+
+type createChildDiskTaskRequest struct {
+	This             types.ManagedObjectReference  `xml:"_this"`
+	ChildName        string                        `xml:"childName"`
+	ChildDatacenter  *types.ManagedObjectReference `xml:"childDatacenter,omitempty"`
+	ParentName       string                        `xml:"parentName"`
+	ParentDatacenter *types.ManagedObjectReference `xml:"parentDatacenter,omitempty"`
+	IsLinkedClone    bool                          `xml:"isLinkedClone"`
+}
+
+type createChildDiskTaskResponse struct {
+	Returnval types.ManagedObjectReference `xml:"returnval"`
+}
+
+type createChildDiskTaskBody struct {
+	Req         *createChildDiskTaskRequest  `xml:"urn:internalvim25 CreateChildDisk_Task,omitempty"`
+	Res         *createChildDiskTaskResponse `xml:"urn:vim25 CreateChildDisk_TaskResponse,omitempty"`
+	InternalRes *createChildDiskTaskResponse `xml:"urn:internalvim25 CreateChildDisk_TaskResponse,omitempty"`
+	Err         *soap.Fault                  `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"`
+}
+
+func (b *createChildDiskTaskBody) Fault() *soap.Fault { return b.Err }
+
+func createChildDiskTask(ctx context.Context, r soap.RoundTripper, req *createChildDiskTaskRequest) (*createChildDiskTaskResponse, error) {
+	var reqBody, resBody createChildDiskTaskBody
+
+	reqBody.Req = req
+
+	if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil {
+		return nil, err
+	}
+
+	if resBody.Res != nil {
+		return resBody.Res, nil // vim-version <= 6.5
+	}
+
+	return resBody.InternalRes, nil // vim-version >= 6.7
+}
+
+func (m VirtualDiskManager) CreateChildDisk(ctx context.Context, parent string, pdc *Datacenter, name string, dc *Datacenter, linked bool) (*Task, error) {
+	req := createChildDiskTaskRequest{
+		This:          m.Reference(),
+		ChildName:     name,
+		ParentName:    parent,
+		IsLinkedClone: linked,
+	}
+
+	if dc != nil {
+		ref := dc.Reference()
+		req.ChildDatacenter = &ref
+	}
+
+	if pdc != nil {
+		ref := pdc.Reference()
+		req.ParentDatacenter = &ref
+	}
+
+	res, err := createChildDiskTask(ctx, m.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(m.Client(), res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/virtual_machine.go

@@ -0,0 +1,801 @@
+/*
+Copyright (c) 2015-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 object
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"path"
+
+	"github.com/vmware/govmomi/nfc"
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25"
+	"github.com/vmware/govmomi/vim25/methods"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+const (
+	PropRuntimePowerState = "summary.runtime.powerState"
+)
+
+type VirtualMachine struct {
+	Common
+}
+
+func NewVirtualMachine(c *vim25.Client, ref types.ManagedObjectReference) *VirtualMachine {
+	return &VirtualMachine{
+		Common: NewCommon(c, ref),
+	}
+}
+
+func (v VirtualMachine) PowerState(ctx context.Context) (types.VirtualMachinePowerState, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{PropRuntimePowerState}, &o)
+	if err != nil {
+		return "", err
+	}
+
+	return o.Summary.Runtime.PowerState, nil
+}
+
+func (v VirtualMachine) PowerOn(ctx context.Context) (*Task, error) {
+	req := types.PowerOnVM_Task{
+		This: v.Reference(),
+	}
+
+	res, err := methods.PowerOnVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) PowerOff(ctx context.Context) (*Task, error) {
+	req := types.PowerOffVM_Task{
+		This: v.Reference(),
+	}
+
+	res, err := methods.PowerOffVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Reset(ctx context.Context) (*Task, error) {
+	req := types.ResetVM_Task{
+		This: v.Reference(),
+	}
+
+	res, err := methods.ResetVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Suspend(ctx context.Context) (*Task, error) {
+	req := types.SuspendVM_Task{
+		This: v.Reference(),
+	}
+
+	res, err := methods.SuspendVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) ShutdownGuest(ctx context.Context) error {
+	req := types.ShutdownGuest{
+		This: v.Reference(),
+	}
+
+	_, err := methods.ShutdownGuest(ctx, v.c, &req)
+	return err
+}
+
+func (v VirtualMachine) RebootGuest(ctx context.Context) error {
+	req := types.RebootGuest{
+		This: v.Reference(),
+	}
+
+	_, err := methods.RebootGuest(ctx, v.c, &req)
+	return err
+}
+
+func (v VirtualMachine) Destroy(ctx context.Context) (*Task, error) {
+	req := types.Destroy_Task{
+		This: v.Reference(),
+	}
+
+	res, err := methods.Destroy_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Clone(ctx context.Context, folder *Folder, name string, config types.VirtualMachineCloneSpec) (*Task, error) {
+	req := types.CloneVM_Task{
+		This:   v.Reference(),
+		Folder: folder.Reference(),
+		Name:   name,
+		Spec:   config,
+	}
+
+	res, err := methods.CloneVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Customize(ctx context.Context, spec types.CustomizationSpec) (*Task, error) {
+	req := types.CustomizeVM_Task{
+		This: v.Reference(),
+		Spec: spec,
+	}
+
+	res, err := methods.CustomizeVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Relocate(ctx context.Context, config types.VirtualMachineRelocateSpec, priority types.VirtualMachineMovePriority) (*Task, error) {
+	req := types.RelocateVM_Task{
+		This:     v.Reference(),
+		Spec:     config,
+		Priority: priority,
+	}
+
+	res, err := methods.RelocateVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Reconfigure(ctx context.Context, config types.VirtualMachineConfigSpec) (*Task, error) {
+	req := types.ReconfigVM_Task{
+		This: v.Reference(),
+		Spec: config,
+	}
+
+	res, err := methods.ReconfigVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) WaitForIP(ctx context.Context) (string, error) {
+	var ip string
+
+	p := property.DefaultCollector(v.c)
+	err := property.Wait(ctx, p, v.Reference(), []string{"guest.ipAddress"}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Name != "guest.ipAddress" {
+				continue
+			}
+			if c.Op != types.PropertyChangeOpAssign {
+				continue
+			}
+			if c.Val == nil {
+				continue
+			}
+
+			ip = c.Val.(string)
+			return true
+		}
+
+		return false
+	})
+
+	if err != nil {
+		return "", err
+	}
+
+	return ip, nil
+}
+
+// WaitForNetIP waits for the VM guest.net property to report an IP address for all VM NICs.
+// Only consider IPv4 addresses if the v4 param is true.
+// By default, wait for all NICs to get an IP address, unless 1 or more device is given.
+// A device can be specified by the MAC address or the device name, e.g. "ethernet-0".
+// Returns a map with MAC address as the key and IP address list as the value.
+func (v VirtualMachine) WaitForNetIP(ctx context.Context, v4 bool, device ...string) (map[string][]string, error) {
+	macs := make(map[string][]string)
+	eths := make(map[string]string)
+
+	p := property.DefaultCollector(v.c)
+
+	// Wait for all NICs to have a MacAddress, which may not be generated yet.
+	err := property.Wait(ctx, p, v.Reference(), []string{"config.hardware.device"}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Op != types.PropertyChangeOpAssign {
+				continue
+			}
+
+			devices := VirtualDeviceList(c.Val.(types.ArrayOfVirtualDevice).VirtualDevice)
+			for _, d := range devices {
+				if nic, ok := d.(types.BaseVirtualEthernetCard); ok {
+					mac := nic.GetVirtualEthernetCard().MacAddress
+					if mac == "" {
+						return false
+					}
+					macs[mac] = nil
+					eths[devices.Name(d)] = mac
+				}
+			}
+		}
+
+		return true
+	})
+
+	if len(device) != 0 {
+		// Only wait for specific NIC(s)
+		macs = make(map[string][]string)
+		for _, mac := range device {
+			if eth, ok := eths[mac]; ok {
+				mac = eth // device name, e.g. "ethernet-0"
+			}
+			macs[mac] = nil
+		}
+	}
+
+	err = property.Wait(ctx, p, v.Reference(), []string{"guest.net"}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Op != types.PropertyChangeOpAssign {
+				continue
+			}
+
+			nics := c.Val.(types.ArrayOfGuestNicInfo).GuestNicInfo
+			for _, nic := range nics {
+				mac := nic.MacAddress
+				if mac == "" || nic.IpConfig == nil {
+					continue
+				}
+
+				for _, ip := range nic.IpConfig.IpAddress {
+					if _, ok := macs[mac]; !ok {
+						continue // Ignore any that don't correspond to a VM device
+					}
+					if v4 && net.ParseIP(ip.IpAddress).To4() == nil {
+						continue // Ignore non IPv4 address
+					}
+					macs[mac] = append(macs[mac], ip.IpAddress)
+				}
+			}
+		}
+
+		for _, ips := range macs {
+			if len(ips) == 0 {
+				return false
+			}
+		}
+
+		return true
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return macs, nil
+}
+
+// Device returns the VirtualMachine's config.hardware.device property.
+func (v VirtualMachine) Device(ctx context.Context) (VirtualDeviceList, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"config.hardware.device", "summary.runtime.connectionState"}, &o)
+	if err != nil {
+		return nil, err
+	}
+
+	// Quoting the SDK doc:
+	//   The virtual machine configuration is not guaranteed to be available.
+	//   For example, the configuration information would be unavailable if the server
+	//   is unable to access the virtual machine files on disk, and is often also unavailable
+	//   during the initial phases of virtual machine creation.
+	if o.Config == nil {
+		return nil, fmt.Errorf("%s Config is not available, connectionState=%s",
+			v.Reference(), o.Summary.Runtime.ConnectionState)
+	}
+
+	return VirtualDeviceList(o.Config.Hardware.Device), nil
+}
+
+func (v VirtualMachine) HostSystem(ctx context.Context) (*HostSystem, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"summary.runtime.host"}, &o)
+	if err != nil {
+		return nil, err
+	}
+
+	host := o.Summary.Runtime.Host
+	if host == nil {
+		return nil, errors.New("VM doesn't have a HostSystem")
+	}
+
+	return NewHostSystem(v.c, *host), nil
+}
+
+func (v VirtualMachine) ResourcePool(ctx context.Context) (*ResourcePool, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"resourcePool"}, &o)
+	if err != nil {
+		return nil, err
+	}
+
+	rp := o.ResourcePool
+	if rp == nil {
+		return nil, errors.New("VM doesn't have a resourcePool")
+	}
+
+	return NewResourcePool(v.c, *rp), nil
+}
+
+func (v VirtualMachine) configureDevice(ctx context.Context, op types.VirtualDeviceConfigSpecOperation, fop types.VirtualDeviceConfigSpecFileOperation, devices ...types.BaseVirtualDevice) error {
+	spec := types.VirtualMachineConfigSpec{}
+
+	for _, device := range devices {
+		config := &types.VirtualDeviceConfigSpec{
+			Device:    device,
+			Operation: op,
+		}
+
+		if disk, ok := device.(*types.VirtualDisk); ok {
+			config.FileOperation = fop
+
+			// Special case to attach an existing disk
+			if op == types.VirtualDeviceConfigSpecOperationAdd && disk.CapacityInKB == 0 {
+				childDisk := false
+				if b, ok := disk.Backing.(*types.VirtualDiskFlatVer2BackingInfo); ok {
+					childDisk = b.Parent != nil
+				}
+
+				if !childDisk {
+					config.FileOperation = "" // existing disk
+				}
+			}
+		}
+
+		spec.DeviceChange = append(spec.DeviceChange, config)
+	}
+
+	task, err := v.Reconfigure(ctx, spec)
+	if err != nil {
+		return err
+	}
+
+	return task.Wait(ctx)
+}
+
+// AddDevice adds the given devices to the VirtualMachine
+func (v VirtualMachine) AddDevice(ctx context.Context, device ...types.BaseVirtualDevice) error {
+	return v.configureDevice(ctx, types.VirtualDeviceConfigSpecOperationAdd, types.VirtualDeviceConfigSpecFileOperationCreate, device...)
+}
+
+// EditDevice edits the given (existing) devices on the VirtualMachine
+func (v VirtualMachine) EditDevice(ctx context.Context, device ...types.BaseVirtualDevice) error {
+	return v.configureDevice(ctx, types.VirtualDeviceConfigSpecOperationEdit, types.VirtualDeviceConfigSpecFileOperationReplace, device...)
+}
+
+// RemoveDevice removes the given devices on the VirtualMachine
+func (v VirtualMachine) RemoveDevice(ctx context.Context, keepFiles bool, device ...types.BaseVirtualDevice) error {
+	fop := types.VirtualDeviceConfigSpecFileOperationDestroy
+	if keepFiles {
+		fop = ""
+	}
+	return v.configureDevice(ctx, types.VirtualDeviceConfigSpecOperationRemove, fop, device...)
+}
+
+// BootOptions returns the VirtualMachine's config.bootOptions property.
+func (v VirtualMachine) BootOptions(ctx context.Context) (*types.VirtualMachineBootOptions, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"config.bootOptions"}, &o)
+	if err != nil {
+		return nil, err
+	}
+
+	return o.Config.BootOptions, nil
+}
+
+// SetBootOptions reconfigures the VirtualMachine with the given options.
+func (v VirtualMachine) SetBootOptions(ctx context.Context, options *types.VirtualMachineBootOptions) error {
+	spec := types.VirtualMachineConfigSpec{}
+
+	spec.BootOptions = options
+
+	task, err := v.Reconfigure(ctx, spec)
+	if err != nil {
+		return err
+	}
+
+	return task.Wait(ctx)
+}
+
+// Answer answers a pending question.
+func (v VirtualMachine) Answer(ctx context.Context, id, answer string) error {
+	req := types.AnswerVM{
+		This:         v.Reference(),
+		QuestionId:   id,
+		AnswerChoice: answer,
+	}
+
+	_, err := methods.AnswerVM(ctx, v.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (v VirtualMachine) AcquireTicket(ctx context.Context, kind string) (*types.VirtualMachineTicket, error) {
+	req := types.AcquireTicket{
+		This:       v.Reference(),
+		TicketType: kind,
+	}
+
+	res, err := methods.AcquireTicket(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return &res.Returnval, nil
+}
+
+// CreateSnapshot creates a new snapshot of a virtual machine.
+func (v VirtualMachine) CreateSnapshot(ctx context.Context, name string, description string, memory bool, quiesce bool) (*Task, error) {
+	req := types.CreateSnapshot_Task{
+		This:        v.Reference(),
+		Name:        name,
+		Description: description,
+		Memory:      memory,
+		Quiesce:     quiesce,
+	}
+
+	res, err := methods.CreateSnapshot_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+// RemoveAllSnapshot removes all snapshots of a virtual machine
+func (v VirtualMachine) RemoveAllSnapshot(ctx context.Context, consolidate *bool) (*Task, error) {
+	req := types.RemoveAllSnapshots_Task{
+		This:        v.Reference(),
+		Consolidate: consolidate,
+	}
+
+	res, err := methods.RemoveAllSnapshots_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+type snapshotMap map[string][]types.ManagedObjectReference
+
+func (m snapshotMap) add(parent string, tree []types.VirtualMachineSnapshotTree) {
+	for i, st := range tree {
+		sname := st.Name
+		names := []string{sname, st.Snapshot.Value}
+
+		if parent != "" {
+			sname = path.Join(parent, sname)
+			// Add full path as an option to resolve duplicate names
+			names = append(names, sname)
+		}
+
+		for _, name := range names {
+			m[name] = append(m[name], tree[i].Snapshot)
+		}
+
+		m.add(sname, st.ChildSnapshotList)
+	}
+}
+
+// FindSnapshot supports snapshot lookup by name, where name can be:
+// 1) snapshot ManagedObjectReference.Value (unique)
+// 2) snapshot name (may not be unique)
+// 3) snapshot tree path (may not be unique)
+func (v VirtualMachine) FindSnapshot(ctx context.Context, name string) (*types.ManagedObjectReference, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"snapshot"}, &o)
+	if err != nil {
+		return nil, err
+	}
+
+	if o.Snapshot == nil || len(o.Snapshot.RootSnapshotList) == 0 {
+		return nil, errors.New("No snapshots for this VM")
+	}
+
+	m := make(snapshotMap)
+	m.add("", o.Snapshot.RootSnapshotList)
+
+	s := m[name]
+	switch len(s) {
+	case 0:
+		return nil, fmt.Errorf("snapshot %q not found", name)
+	case 1:
+		return &s[0], nil
+	default:
+		return nil, fmt.Errorf("%q resolves to %d snapshots", name, len(s))
+	}
+}
+
+// RemoveSnapshot removes a named snapshot
+func (v VirtualMachine) RemoveSnapshot(ctx context.Context, name string, removeChildren bool, consolidate *bool) (*Task, error) {
+	snapshot, err := v.FindSnapshot(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+
+	req := types.RemoveSnapshot_Task{
+		This:           snapshot.Reference(),
+		RemoveChildren: removeChildren,
+		Consolidate:    consolidate,
+	}
+
+	res, err := methods.RemoveSnapshot_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+// RevertToCurrentSnapshot reverts to the current snapshot
+func (v VirtualMachine) RevertToCurrentSnapshot(ctx context.Context, suppressPowerOn bool) (*Task, error) {
+	req := types.RevertToCurrentSnapshot_Task{
+		This:            v.Reference(),
+		SuppressPowerOn: types.NewBool(suppressPowerOn),
+	}
+
+	res, err := methods.RevertToCurrentSnapshot_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+// RevertToSnapshot reverts to a named snapshot
+func (v VirtualMachine) RevertToSnapshot(ctx context.Context, name string, suppressPowerOn bool) (*Task, error) {
+	snapshot, err := v.FindSnapshot(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+
+	req := types.RevertToSnapshot_Task{
+		This:            snapshot.Reference(),
+		SuppressPowerOn: types.NewBool(suppressPowerOn),
+	}
+
+	res, err := methods.RevertToSnapshot_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+// IsToolsRunning returns true if VMware Tools is currently running in the guest OS, and false otherwise.
+func (v VirtualMachine) IsToolsRunning(ctx context.Context) (bool, error) {
+	var o mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"guest.toolsRunningStatus"}, &o)
+	if err != nil {
+		return false, err
+	}
+
+	return o.Guest.ToolsRunningStatus == string(types.VirtualMachineToolsRunningStatusGuestToolsRunning), nil
+}
+
+// Wait for the VirtualMachine to change to the desired power state.
+func (v VirtualMachine) WaitForPowerState(ctx context.Context, state types.VirtualMachinePowerState) error {
+	p := property.DefaultCollector(v.c)
+	err := property.Wait(ctx, p, v.Reference(), []string{PropRuntimePowerState}, func(pc []types.PropertyChange) bool {
+		for _, c := range pc {
+			if c.Name != PropRuntimePowerState {
+				continue
+			}
+			if c.Val == nil {
+				continue
+			}
+
+			ps := c.Val.(types.VirtualMachinePowerState)
+			if ps == state {
+				return true
+			}
+		}
+		return false
+	})
+
+	return err
+}
+
+func (v VirtualMachine) MarkAsTemplate(ctx context.Context) error {
+	req := types.MarkAsTemplate{
+		This: v.Reference(),
+	}
+
+	_, err := methods.MarkAsTemplate(ctx, v.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (v VirtualMachine) MarkAsVirtualMachine(ctx context.Context, pool ResourcePool, host *HostSystem) error {
+	req := types.MarkAsVirtualMachine{
+		This: v.Reference(),
+		Pool: pool.Reference(),
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	_, err := methods.MarkAsVirtualMachine(ctx, v.c, &req)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (v VirtualMachine) Migrate(ctx context.Context, pool *ResourcePool, host *HostSystem, priority types.VirtualMachineMovePriority, state types.VirtualMachinePowerState) (*Task, error) {
+	req := types.MigrateVM_Task{
+		This:     v.Reference(),
+		Priority: priority,
+		State:    state,
+	}
+
+	if pool != nil {
+		ref := pool.Reference()
+		req.Pool = &ref
+	}
+
+	if host != nil {
+		ref := host.Reference()
+		req.Host = &ref
+	}
+
+	res, err := methods.MigrateVM_Task(ctx, v.c, &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Unregister(ctx context.Context) error {
+	req := types.UnregisterVM{
+		This: v.Reference(),
+	}
+
+	_, err := methods.UnregisterVM(ctx, v.Client(), &req)
+	return err
+}
+
+// QueryEnvironmentBrowser is a helper to get the environmentBrowser property.
+func (v VirtualMachine) QueryConfigTarget(ctx context.Context) (*types.ConfigTarget, error) {
+	var vm mo.VirtualMachine
+
+	err := v.Properties(ctx, v.Reference(), []string{"environmentBrowser"}, &vm)
+	if err != nil {
+		return nil, err
+	}
+
+	req := types.QueryConfigTarget{
+		This: vm.EnvironmentBrowser,
+	}
+
+	res, err := methods.QueryConfigTarget(ctx, v.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Returnval, nil
+}
+
+func (v VirtualMachine) MountToolsInstaller(ctx context.Context) error {
+	req := types.MountToolsInstaller{
+		This: v.Reference(),
+	}
+
+	_, err := methods.MountToolsInstaller(ctx, v.Client(), &req)
+	return err
+}
+
+func (v VirtualMachine) UnmountToolsInstaller(ctx context.Context) error {
+	req := types.UnmountToolsInstaller{
+		This: v.Reference(),
+	}
+
+	_, err := methods.UnmountToolsInstaller(ctx, v.Client(), &req)
+	return err
+}
+
+func (v VirtualMachine) UpgradeTools(ctx context.Context, options string) (*Task, error) {
+	req := types.UpgradeTools_Task{
+		This:             v.Reference(),
+		InstallerOptions: options,
+	}
+
+	res, err := methods.UpgradeTools_Task(ctx, v.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) Export(ctx context.Context) (*nfc.Lease, error) {
+	req := types.ExportVm{
+		This: v.Reference(),
+	}
+
+	res, err := methods.ExportVm(ctx, v.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return nfc.NewLease(v.c, res.Returnval), nil
+}
+
+func (v VirtualMachine) UpgradeVM(ctx context.Context, version string) (*Task, error) {
+	req := types.UpgradeVM_Task{
+		This:    v.Reference(),
+		Version: version,
+	}
+
+	res, err := methods.UpgradeVM_Task(ctx, v.Client(), &req)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewTask(v.c, res.Returnval), nil
+}

vendor/github.com/vmware/govmomi/object/virtual_machine_test.go

@@ -0,0 +1,206 @@
+/*
+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 object
+
+import (
+	"testing"
+	"time"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+// VirtualMachine should implement the Reference interface.
+var _ Reference = VirtualMachine{}
+
+// pretty.Printf generated
+var snapshot = &types.VirtualMachineSnapshotInfo{
+	DynamicData:     types.DynamicData{},
+	CurrentSnapshot: &types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-11"},
+	RootSnapshotList: []types.VirtualMachineSnapshotTree{
+		{
+			DynamicData:    types.DynamicData{},
+			Snapshot:       types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-1"},
+			Vm:             types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+			Name:           "root",
+			Description:    "",
+			Id:             1,
+			CreateTime:     time.Now(),
+			State:          "poweredOn",
+			Quiesced:       false,
+			BackupManifest: "",
+			ChildSnapshotList: []types.VirtualMachineSnapshotTree{
+				{
+					DynamicData:       types.DynamicData{},
+					Snapshot:          types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-2"},
+					Vm:                types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+					Name:              "child",
+					Description:       "",
+					Id:                2,
+					CreateTime:        time.Now(),
+					State:             "poweredOn",
+					Quiesced:          false,
+					BackupManifest:    "",
+					ChildSnapshotList: nil,
+					ReplaySupported:   types.NewBool(false),
+				},
+				{
+					DynamicData:    types.DynamicData{},
+					Snapshot:       types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-3"},
+					Vm:             types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+					Name:           "child",
+					Description:    "",
+					Id:             3,
+					CreateTime:     time.Now(),
+					State:          "poweredOn",
+					Quiesced:       false,
+					BackupManifest: "",
+					ChildSnapshotList: []types.VirtualMachineSnapshotTree{
+						{
+							DynamicData:    types.DynamicData{},
+							Snapshot:       types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-9"},
+							Vm:             types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+							Name:           "grandkid",
+							Description:    "",
+							Id:             9,
+							CreateTime:     time.Now(),
+							State:          "poweredOn",
+							Quiesced:       false,
+							BackupManifest: "",
+							ChildSnapshotList: []types.VirtualMachineSnapshotTree{
+								{
+									DynamicData:       types.DynamicData{},
+									Snapshot:          types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-10"},
+									Vm:                types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+									Name:              "great",
+									Description:       "",
+									Id:                10,
+									CreateTime:        time.Now(),
+									State:             "poweredOn",
+									Quiesced:          false,
+									BackupManifest:    "",
+									ChildSnapshotList: nil,
+									ReplaySupported:   types.NewBool(false),
+								},
+							},
+							ReplaySupported: types.NewBool(false),
+						},
+					},
+					ReplaySupported: types.NewBool(false),
+				},
+				{
+					DynamicData:    types.DynamicData{},
+					Snapshot:       types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-5"},
+					Vm:             types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+					Name:           "voodoo",
+					Description:    "",
+					Id:             5,
+					CreateTime:     time.Now(),
+					State:          "poweredOn",
+					Quiesced:       false,
+					BackupManifest: "",
+					ChildSnapshotList: []types.VirtualMachineSnapshotTree{
+						{
+							DynamicData:       types.DynamicData{},
+							Snapshot:          types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-11"},
+							Vm:                types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+							Name:              "child",
+							Description:       "",
+							Id:                11,
+							CreateTime:        time.Now(),
+							State:             "poweredOn",
+							Quiesced:          false,
+							BackupManifest:    "",
+							ChildSnapshotList: nil,
+							ReplaySupported:   types.NewBool(false),
+						},
+					},
+					ReplaySupported: types.NewBool(false),
+				},
+				{
+					DynamicData:    types.DynamicData{},
+					Snapshot:       types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-6"},
+					Vm:             types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+					Name:           "better",
+					Description:    "",
+					Id:             6,
+					CreateTime:     time.Now(),
+					State:          "poweredOn",
+					Quiesced:       false,
+					BackupManifest: "",
+					ChildSnapshotList: []types.VirtualMachineSnapshotTree{
+						{
+							DynamicData:    types.DynamicData{},
+							Snapshot:       types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-7"},
+							Vm:             types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+							Name:           "best",
+							Description:    "",
+							Id:             7,
+							CreateTime:     time.Now(),
+							State:          "poweredOn",
+							Quiesced:       false,
+							BackupManifest: "",
+							ChildSnapshotList: []types.VirtualMachineSnapshotTree{
+								{
+									DynamicData:       types.DynamicData{},
+									Snapshot:          types.ManagedObjectReference{Type: "VirtualMachineSnapshot", Value: "2-snapshot-8"},
+									Vm:                types.ManagedObjectReference{Type: "VirtualMachine", Value: "2"},
+									Name:              "betterer",
+									Description:       "",
+									Id:                8,
+									CreateTime:        time.Now(),
+									State:             "poweredOn",
+									Quiesced:          false,
+									BackupManifest:    "",
+									ChildSnapshotList: nil,
+									ReplaySupported:   types.NewBool(false),
+								},
+							},
+							ReplaySupported: types.NewBool(false),
+						},
+					},
+					ReplaySupported: types.NewBool(false),
+				},
+			},
+			ReplaySupported: types.NewBool(false),
+		},
+	},
+}
+
+func TestVirtualMachineSnapshotMap(t *testing.T) {
+	m := make(snapshotMap)
+	m.add("", snapshot.RootSnapshotList)
+
+	tests := []struct {
+		name   string
+		expect int
+	}{
+		{"enoent", 0},
+		{"root", 1},
+		{"child", 3},
+		{"root/child", 2},
+		{"root/voodoo/child", 1},
+		{"2-snapshot-6", 1},
+	}
+
+	for _, test := range tests {
+		s := m[test.name]
+
+		if len(s) != test.expect {
+			t.Errorf("%s: %d != %d", test.name, len(s), test.expect)
+		}
+	}
+}

vendor/github.com/vmware/govmomi/object/vmware_distributed_virtual_switch.go

@@ -0,0 +1,21 @@
+/*
+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 object
+
+type VmwareDistributedVirtualSwitch struct {
+	DistributedVirtualSwitch
+}