add vendoring with go dep

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

@@ -0,0 +1,107 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"errors"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+)
+
+type cp struct {
+	*flags.OutputFlag
+	*flags.DatastoreFlag
+
+	force bool
+}
+
+func init() {
+	cli.Register("datastore.cp", &cp{})
+}
+
+func (cmd *cp) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
+	cmd.OutputFlag.Register(ctx, f)
+
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.force, "f", false, "If true, overwrite any identically named file at the destination")
+}
+
+func (cmd *cp) Process(ctx context.Context) error {
+	if err := cmd.OutputFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *cp) Usage() string {
+	return "SRC DST"
+}
+
+func (cmd *cp) Description() string {
+	return `Copy SRC to DST on DATASTORE.
+
+Examples:
+  govc datastore.cp foo/foo.vmx foo/foo.vmx.old
+  govc datastore.cp -f my.vmx foo/foo.vmx`
+}
+
+func (cmd *cp) Run(ctx context.Context, f *flag.FlagSet) error {
+	args := f.Args()
+	if len(args) != 2 {
+		return errors.New("SRC and DST arguments are required")
+	}
+
+	c, err := cmd.Client()
+	if err != nil {
+		return err
+	}
+
+	dc, err := cmd.Datacenter()
+	if err != nil {
+		return err
+	}
+
+	// TODO: support cross-datacenter copy
+
+	src, err := cmd.DatastorePath(args[0])
+	if err != nil {
+		return err
+	}
+
+	dst, err := cmd.DatastorePath(args[1])
+	if err != nil {
+		return err
+	}
+
+	m := object.NewFileManager(c)
+	task, err := m.CopyDatastoreFile(ctx, src, dc, dst, dc, cmd.force)
+	if err != nil {
+		return err
+	}
+
+	return task.Wait(ctx)
+}

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

@@ -0,0 +1,321 @@
+/*
+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 datastore
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type create struct {
+	*flags.HostSystemFlag
+
+	// Generic options
+	Type  typeFlag
+	Name  string
+	Force bool
+
+	// Options for NAS
+	RemoteHost string
+	RemotePath string
+	AccessMode string
+	UserName   string
+	Password   string
+
+	// Options for VMFS
+	DiskCanonicalName string
+
+	// Options for local
+	Path string
+}
+
+func init() {
+	cli.Register("datastore.create", &create{})
+}
+
+var nasTypes = []string{
+	string(types.HostFileSystemVolumeFileSystemTypeNFS),
+	string(types.HostFileSystemVolumeFileSystemTypeNFS41),
+	string(types.HostFileSystemVolumeFileSystemTypeCIFS),
+}
+
+var vmfsTypes = []string{
+	string(types.HostFileSystemVolumeFileSystemTypeVMFS),
+}
+
+var localTypes = []string{
+	"local",
+}
+
+var allTypes = []string{}
+
+func init() {
+	allTypes = append(allTypes, nasTypes...)
+	allTypes = append(allTypes, vmfsTypes...)
+	allTypes = append(allTypes, localTypes...)
+}
+
+type typeFlag string
+
+func (t *typeFlag) Set(s string) error {
+	s = strings.ToLower(s)
+	for _, e := range allTypes {
+		if s == strings.ToLower(e) {
+			*t = typeFlag(e)
+			return nil
+		}
+	}
+
+	return fmt.Errorf("unknown type")
+}
+
+func (t *typeFlag) String() string {
+	return string(*t)
+}
+
+func (t *typeFlag) partOf(m []string) bool {
+	for _, e := range m {
+		if t.String() == e {
+			return true
+		}
+	}
+	return false
+}
+
+func (t *typeFlag) IsNasType() bool {
+	return t.partOf(nasTypes)
+}
+
+func (t *typeFlag) IsVmfsType() bool {
+	return t.partOf(vmfsTypes)
+}
+
+func (t *typeFlag) IsLocalType() bool {
+	return t.partOf(localTypes)
+}
+
+func (cmd *create) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
+	cmd.HostSystemFlag.Register(ctx, f)
+
+	modes := []string{
+		string(types.HostMountModeReadOnly),
+		string(types.HostMountModeReadWrite),
+	}
+
+	f.StringVar(&cmd.Name, "name", "", "Datastore name")
+	f.Var(&cmd.Type, "type", fmt.Sprintf("Datastore type (%s)", strings.Join(allTypes, "|")))
+	f.BoolVar(&cmd.Force, "force", false, "Ignore DuplicateName error if datastore is already mounted on a host")
+
+	// Options for NAS
+	f.StringVar(&cmd.RemoteHost, "remote-host", "", "Remote hostname of the NAS datastore")
+	f.StringVar(&cmd.RemotePath, "remote-path", "", "Remote path of the NFS mount point")
+	f.StringVar(&cmd.AccessMode, "mode", modes[0],
+		fmt.Sprintf("Access mode for the mount point (%s)", strings.Join(modes, "|")))
+	f.StringVar(&cmd.UserName, "username", "", "Username to use when connecting (CIFS only)")
+	f.StringVar(&cmd.Password, "password", "", "Password to use when connecting (CIFS only)")
+
+	// Options for VMFS
+	f.StringVar(&cmd.DiskCanonicalName, "disk", "", "Canonical name of disk (VMFS only)")
+
+	// Options for Local
+	f.StringVar(&cmd.Path, "path", "", "Local directory path for the datastore (local only)")
+}
+
+func (cmd *create) Process(ctx context.Context) error {
+	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *create) Usage() string {
+	return "HOST..."
+}
+
+func (cmd *create) Description() string {
+	return `Create datastore on HOST.
+
+Examples:
+  govc datastore.create -type nfs -name nfsDatastore -remote-host 10.143.2.232 -remote-path /share cluster1
+  govc datastore.create -type vmfs -name vmfsDatastore -disk=mpx.vmhba0:C0:T0:L0 cluster1
+  govc datastore.create -type local -name localDatastore -path /var/datastore host1`
+}
+
+func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
+	hosts, err := cmd.HostSystems(f.Args())
+	if err != nil {
+		return err
+	}
+
+	switch {
+	case cmd.Type.IsNasType():
+		return cmd.CreateNasDatastore(ctx, hosts)
+	case cmd.Type.IsVmfsType():
+		return cmd.CreateVmfsDatastore(ctx, hosts)
+	case cmd.Type.IsLocalType():
+		return cmd.CreateLocalDatastore(ctx, hosts)
+	default:
+		return fmt.Errorf("unhandled type %#v", cmd.Type)
+	}
+}
+
+func (cmd *create) GetHostNasVolumeSpec() types.HostNasVolumeSpec {
+	localPath := cmd.Path
+	if localPath == "" {
+		localPath = cmd.Name
+	}
+
+	s := types.HostNasVolumeSpec{
+		LocalPath:  localPath,
+		Type:       cmd.Type.String(),
+		RemoteHost: cmd.RemoteHost,
+		RemotePath: cmd.RemotePath,
+		AccessMode: cmd.AccessMode,
+		UserName:   cmd.UserName,
+		Password:   cmd.Password,
+	}
+
+	return s
+}
+
+func (cmd *create) CreateNasDatastore(ctx context.Context, hosts []*object.HostSystem) error {
+	object := types.ManagedObjectReference{
+		Type:  "Datastore",
+		Value: fmt.Sprintf("%s:%s", cmd.RemoteHost, cmd.RemotePath),
+	}
+
+	spec := cmd.GetHostNasVolumeSpec()
+
+	for _, host := range hosts {
+		ds, err := host.ConfigManager().DatastoreSystem(ctx)
+		if err != nil {
+			return err
+		}
+
+		_, err = ds.CreateNasDatastore(ctx, spec)
+		if err != nil {
+			if soap.IsSoapFault(err) {
+				switch fault := soap.ToSoapFault(err).VimFault().(type) {
+				case types.PlatformConfigFault:
+					if len(fault.FaultMessage) != 0 {
+						return errors.New(fault.FaultMessage[0].Message)
+					}
+				case types.DuplicateName:
+					if cmd.Force && fault.Object == object {
+						fmt.Fprintf(os.Stderr, "%s: '%s' already mounted\n",
+							host.InventoryPath, cmd.Name)
+						continue
+					}
+				}
+			}
+
+			return fmt.Errorf("%s: %s", host.InventoryPath, err)
+		}
+	}
+
+	return nil
+}
+
+func (cmd *create) CreateVmfsDatastore(ctx context.Context, hosts []*object.HostSystem) error {
+	for _, host := range hosts {
+		ds, err := host.ConfigManager().DatastoreSystem(ctx)
+		if err != nil {
+			return err
+		}
+
+		// Find the specified disk
+		disks, err := ds.QueryAvailableDisksForVmfs(ctx)
+		if err != nil {
+			return err
+		}
+
+		var disk *types.HostScsiDisk
+		for _, e := range disks {
+			if e.CanonicalName == cmd.DiskCanonicalName {
+				disk = &e
+				break
+			}
+		}
+
+		if disk == nil {
+			return fmt.Errorf("no eligible disk found for name %#v", cmd.DiskCanonicalName)
+		}
+
+		// Query for creation options and pick the right one
+		options, err := ds.QueryVmfsDatastoreCreateOptions(ctx, disk.DevicePath)
+		if err != nil {
+			return err
+		}
+
+		var option *types.VmfsDatastoreOption
+		for _, e := range options {
+			if _, ok := e.Info.(*types.VmfsDatastoreAllExtentOption); ok {
+				option = &e
+				break
+			}
+		}
+
+		if option == nil {
+			return fmt.Errorf("cannot use entire disk for datastore for name %#v", cmd.DiskCanonicalName)
+		}
+
+		spec := *option.Spec.(*types.VmfsDatastoreCreateSpec)
+		spec.Vmfs.VolumeName = cmd.Name
+		_, err = ds.CreateVmfsDatastore(ctx, spec)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (cmd *create) CreateLocalDatastore(ctx context.Context, hosts []*object.HostSystem) error {
+	for _, host := range hosts {
+		ds, err := host.ConfigManager().DatastoreSystem(ctx)
+		if err != nil {
+			return err
+		}
+
+		if cmd.Path == "" {
+			cmd.Path = cmd.Name
+		}
+
+		if cmd.Name == "" {
+			cmd.Name = filepath.Base(cmd.Path)
+		}
+
+		_, err = ds.CreateLocalDatastore(ctx, cmd.Name, cmd.Path)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/datastore/disk/create.go

@@ -0,0 +1,98 @@
+/*
+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 disk
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/units"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type create struct {
+	*flags.DatastoreFlag
+
+	Bytes units.ByteSize
+}
+
+func init() {
+	cli.Register("datastore.disk.create", &create{})
+}
+
+func (cmd *create) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	_ = cmd.Bytes.Set("10G")
+	f.Var(&cmd.Bytes, "size", "Size of new disk")
+}
+
+func (cmd *create) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *create) Usage() string {
+	return "VMDK"
+}
+
+func (cmd *create) Description() string {
+	return `Create VMDK on DS.
+
+Examples:
+  govc datastore.mkdir disks
+  govc datastore.disk.create -size 24G disks/disk1.vmdk`
+}
+
+func (cmd *create) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() == 0 {
+		return flag.ErrHelp
+	}
+
+	dc, err := cmd.Datacenter()
+	if err != nil {
+		return err
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	m := object.NewVirtualDiskManager(ds.Client())
+
+	spec := &types.FileBackedVirtualDiskSpec{
+		VirtualDiskSpec: types.VirtualDiskSpec{
+			AdapterType: string(types.VirtualDiskAdapterTypeLsiLogic),
+			DiskType:    string(types.VirtualDiskTypeThin),
+		},
+		CapacityKb: int64(cmd.Bytes) / 1024,
+	}
+
+	task, err := m.CreateVirtualDisk(ctx, ds.Path(f.Arg(0)), dc, spec)
+	if err != nil {
+		return err
+	}
+
+	return task.Wait(ctx)
+}

vendor/github.com/vmware/govmomi/govc/datastore/disk/info.go

@@ -0,0 +1,145 @@
+/*
+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 disk
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+)
+
+type info struct {
+	*flags.DatastoreFlag
+
+	c bool
+	d bool
+	p bool
+}
+
+func init() {
+	cli.Register("datastore.disk.info", &info{})
+}
+
+func (cmd *info) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.c, "c", false, "Chain format")
+	f.BoolVar(&cmd.d, "d", false, "Include datastore in output")
+	f.BoolVar(&cmd.p, "p", true, "Include parents")
+}
+
+func (cmd *info) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *info) Usage() string {
+	return "VMDK"
+}
+
+func (cmd *info) Description() string {
+	return `Query VMDK info on DS.
+
+Examples:
+  govc datastore.disk.info disks/disk1.vmdk`
+}
+
+func fullPath(s string) string {
+	return s
+}
+
+func dsPath(s string) string {
+	var p object.DatastorePath
+
+	if p.FromString(s) {
+		return p.Path
+	}
+
+	return s
+}
+
+var infoPath = dsPath
+
+type infoResult []object.VirtualDiskInfo
+
+func (r infoResult) Write(w io.Writer) error {
+	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
+
+	for _, info := range r {
+		fmt.Fprintf(tw, "Name:\t%s\n", infoPath(info.Name))
+		fmt.Fprintf(tw, "  Type:\t%s\n", info.DiskType)
+		fmt.Fprintf(tw, "  Parent:\t%s\n", infoPath(info.Parent))
+	}
+
+	return tw.Flush()
+}
+
+type chainResult []object.VirtualDiskInfo
+
+func (r chainResult) Write(w io.Writer) error {
+	for i, info := range r {
+		fmt.Fprint(w, strings.Repeat(" ", i*2))
+		fmt.Fprintln(w, infoPath(info.Name))
+	}
+
+	return nil
+}
+
+func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 1 {
+		return flag.ErrHelp
+	}
+
+	dc, err := cmd.Datacenter()
+	if err != nil {
+		return err
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	m := object.NewVirtualDiskManager(ds.Client())
+
+	info, err := m.QueryVirtualDiskInfo(ctx, ds.Path(f.Arg(0)), dc, cmd.p)
+	if err != nil {
+		return err
+	}
+
+	if cmd.d {
+		infoPath = fullPath
+	}
+
+	var r flags.OutputWriter = infoResult(info)
+
+	if cmd.c {
+		r = chainResult(info)
+	}
+
+	return cmd.WriteResult(r)
+}

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

@@ -0,0 +1,117 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type download struct {
+	*flags.DatastoreFlag
+	*flags.HostSystemFlag
+}
+
+func init() {
+	cli.Register("datastore.download", &download{})
+}
+
+func (cmd *download) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
+	cmd.HostSystemFlag.Register(ctx, f)
+}
+
+func (cmd *download) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *download) Usage() string {
+	return "SOURCE DEST"
+}
+
+func (cmd *download) Description() string {
+	return `Copy SOURCE from DS to DEST on the local system.
+
+If DEST name is "-", source is written to stdout.
+
+Examples:
+  govc datastore.download vm-name/vmware.log ./local.log
+  govc datastore.download vm-name/vmware.log - | grep -i error`
+}
+
+func (cmd *download) Run(ctx context.Context, f *flag.FlagSet) error {
+	args := f.Args()
+	if len(args) != 2 {
+		return errors.New("invalid arguments")
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	h, err := cmd.HostSystemIfSpecified()
+	if err != nil {
+		return err
+	}
+
+	var via string
+
+	if h != nil {
+		via = fmt.Sprintf(" via %s", h.InventoryPath)
+		ctx = ds.HostContext(ctx, h)
+	}
+
+	p := soap.DefaultDownload
+
+	src := args[0]
+	dst := args[1]
+
+	if dst == "-" {
+		f, _, err := ds.Download(ctx, src, &p)
+		if err != nil {
+			return err
+		}
+		_, err = io.Copy(os.Stdout, f)
+		return err
+	}
+
+	if cmd.DatastoreFlag.OutputFlag.TTY {
+		logger := cmd.DatastoreFlag.ProgressLogger(fmt.Sprintf("Downloading%s... ", via))
+		p.Progress = logger
+		defer logger.Wait()
+	}
+
+	return ds.DownloadFile(ctx, src, dst, &p)
+}

vendor/github.com/vmware/govmomi/govc/datastore/info.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 datastore
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/property"
+	"github.com/vmware/govmomi/vim25/mo"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type info struct {
+	*flags.ClientFlag
+	*flags.OutputFlag
+	*flags.DatacenterFlag
+}
+
+func init() {
+	cli.Register("datastore.info", &info{})
+}
+
+func (cmd *info) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.ClientFlag, ctx = flags.NewClientFlag(ctx)
+	cmd.ClientFlag.Register(ctx, f)
+
+	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
+	cmd.OutputFlag.Register(ctx, f)
+
+	cmd.DatacenterFlag, ctx = flags.NewDatacenterFlag(ctx)
+	cmd.DatacenterFlag.Register(ctx, f)
+}
+
+func (cmd *info) Process(ctx context.Context) error {
+	if err := cmd.ClientFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.OutputFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.DatacenterFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *info) Usage() string {
+	return "[PATH]..."
+}
+
+func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
+	c, err := cmd.Client()
+	if err != nil {
+		return err
+	}
+
+	finder, err := cmd.Finder()
+	if err != nil {
+		return err
+	}
+
+	args := f.Args()
+	if len(args) == 0 {
+		args = []string{"*"}
+	}
+
+	var res infoResult
+	var props []string
+
+	if cmd.OutputFlag.JSON {
+		props = nil // Load everything
+	} else {
+		props = []string{"info", "summary"} // Load summary
+	}
+
+	for _, arg := range args {
+		objects, err := finder.DatastoreList(ctx, arg)
+		if err != nil {
+			return err
+		}
+		res.objects = append(res.objects, objects...)
+	}
+
+	if len(res.objects) != 0 {
+		refs := make([]types.ManagedObjectReference, 0, len(res.objects))
+		for _, o := range res.objects {
+			refs = append(refs, o.Reference())
+		}
+
+		pc := property.DefaultCollector(c)
+		err = pc.Retrieve(ctx, refs, props, &res.Datastores)
+		if err != nil {
+			return err
+		}
+	}
+
+	return cmd.WriteResult(&res)
+}
+
+type infoResult struct {
+	Datastores []mo.Datastore
+	objects    []*object.Datastore
+}
+
+func (r *infoResult) Write(w io.Writer) error {
+	// Maintain order via r.objects as Property collector does not always return results in order.
+	objects := make(map[types.ManagedObjectReference]mo.Datastore, len(r.Datastores))
+	for _, o := range r.Datastores {
+		objects[o.Reference()] = o
+	}
+
+	tw := tabwriter.NewWriter(os.Stdout, 2, 0, 2, ' ', 0)
+
+	for _, o := range r.objects {
+		ds := objects[o.Reference()]
+		s := ds.Summary
+		fmt.Fprintf(tw, "Name:\t%s\n", s.Name)
+		fmt.Fprintf(tw, "  Path:\t%s\n", o.InventoryPath)
+		fmt.Fprintf(tw, "  Type:\t%s\n", s.Type)
+		fmt.Fprintf(tw, "  URL:\t%s\n", s.Url)
+		fmt.Fprintf(tw, "  Capacity:\t%.1f GB\n", float64(s.Capacity)/(1<<30))
+		fmt.Fprintf(tw, "  Free:\t%.1f GB\n", float64(s.FreeSpace)/(1<<30))
+
+		switch info := ds.Info.(type) {
+		case *types.NasDatastoreInfo:
+			fmt.Fprintf(tw, "  Remote:\t%s:%s\n", info.Nas.RemoteHost, info.Nas.RemotePath)
+		}
+	}
+
+	return tw.Flush()
+}

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

@@ -0,0 +1,277 @@
+/*
+Copyright (c) 2014-2016 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"path"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/units"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ls struct {
+	*flags.DatastoreFlag
+	*flags.OutputFlag
+
+	long    bool
+	slash   bool
+	all     bool
+	recurse bool
+}
+
+func init() {
+	cli.Register("datastore.ls", &ls{})
+}
+
+func (cmd *ls) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
+	cmd.OutputFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.long, "l", false, "Long listing format")
+	f.BoolVar(&cmd.slash, "p", false, "Append / indicator to directories")
+	f.BoolVar(&cmd.all, "a", false, "Do not ignore entries starting with .")
+	f.BoolVar(&cmd.recurse, "R", false, "List subdirectories recursively")
+}
+
+func (cmd *ls) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.OutputFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *ls) Usage() string {
+	return "[FILE]..."
+}
+
+func isInvalid(err error) bool {
+	if f, ok := err.(types.HasFault); ok {
+		switch f.Fault().(type) {
+		case *types.InvalidArgument:
+			return true
+		}
+	}
+
+	return false
+}
+
+func (cmd *ls) Run(ctx context.Context, f *flag.FlagSet) error {
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	b, err := ds.Browser(ctx)
+	if err != nil {
+		return err
+	}
+
+	args := f.Args()
+	if len(args) == 0 {
+		args = []string{""}
+	}
+
+	result := &listOutput{
+		rs:  make([]types.HostDatastoreBrowserSearchResults, 0),
+		cmd: cmd,
+	}
+
+	for _, arg := range args {
+		spec := types.HostDatastoreBrowserSearchSpec{
+			MatchPattern: []string{"*"},
+		}
+
+		if cmd.long {
+			spec.Details = &types.FileQueryFlags{
+				FileType:     true,
+				FileSize:     true,
+				FileOwner:    types.NewBool(true), // TODO: omitempty is generated, but seems to be required
+				Modification: true,
+			}
+		}
+
+		for i := 0; ; i++ {
+			r, err := cmd.ListPath(b, arg, spec)
+			if err != nil {
+				// Treat the argument as a match pattern if not found as directory
+				if i == 0 && types.IsFileNotFound(err) || isInvalid(err) {
+					spec.MatchPattern[0] = path.Base(arg)
+					arg = path.Dir(arg)
+					continue
+				}
+
+				return err
+			}
+
+			// Treat an empty result against match pattern as file not found
+			if i == 1 && len(r) == 1 && len(r[0].File) == 0 {
+				return fmt.Errorf("File %s/%s was not found", r[0].FolderPath, spec.MatchPattern[0])
+			}
+
+			for n := range r {
+				result.add(r[n])
+			}
+
+			break
+		}
+	}
+
+	return cmd.WriteResult(result)
+}
+
+func (cmd *ls) ListPath(b *object.HostDatastoreBrowser, path string, spec types.HostDatastoreBrowserSearchSpec) ([]types.HostDatastoreBrowserSearchResults, error) {
+	ctx := context.TODO()
+
+	path, err := cmd.DatastorePath(path)
+	if err != nil {
+		return nil, err
+	}
+
+	search := b.SearchDatastore
+	if cmd.recurse {
+		search = b.SearchDatastoreSubFolders
+	}
+
+	task, err := search(ctx, path, &spec)
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := task.WaitForResult(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	switch r := info.Result.(type) {
+	case types.HostDatastoreBrowserSearchResults:
+		return []types.HostDatastoreBrowserSearchResults{r}, nil
+	case types.ArrayOfHostDatastoreBrowserSearchResults:
+		return r.HostDatastoreBrowserSearchResults, nil
+	default:
+		panic(fmt.Sprintf("unknown result type: %T", r))
+	}
+}
+
+type listOutput struct {
+	rs  []types.HostDatastoreBrowserSearchResults
+	cmd *ls
+}
+
+func (o *listOutput) add(r types.HostDatastoreBrowserSearchResults) {
+	if o.cmd.recurse && !o.cmd.all {
+		// filter out ".hidden" directories
+		path := strings.SplitN(r.FolderPath, " ", 2)
+		if len(path) == 2 {
+			path = strings.Split(path[1], "/")
+			if path[0] == "." {
+				path = path[1:]
+			}
+
+			for _, p := range path {
+				if len(p) != 0 && p[0] == '.' {
+					return
+				}
+			}
+		}
+	}
+
+	res := r
+	res.File = nil
+
+	for _, f := range r.File {
+		if f.GetFileInfo().Path[0] == '.' && !o.cmd.all {
+			continue
+		}
+
+		if o.cmd.slash {
+			if d, ok := f.(*types.FolderFileInfo); ok {
+				d.Path += "/"
+			}
+		}
+
+		res.File = append(res.File, f)
+	}
+
+	o.rs = append(o.rs, res)
+}
+
+// hasMultiplePaths returns whether or not the slice of search results contains
+// results from more than one folder path.
+func (o *listOutput) hasMultiplePaths() bool {
+	if len(o.rs) == 0 {
+		return false
+	}
+
+	p := o.rs[0].FolderPath
+
+	// Multiple paths if any entry is not equal to the first one.
+	for _, e := range o.rs {
+		if e.FolderPath != p {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (o *listOutput) MarshalJSON() ([]byte, error) {
+	return json.Marshal(o.rs)
+}
+
+func (o *listOutput) Write(w io.Writer) error {
+	// Only include path header if we're dealing with more than one path.
+	includeHeader := false
+	if o.hasMultiplePaths() {
+		includeHeader = true
+	}
+
+	tw := tabwriter.NewWriter(w, 3, 0, 2, ' ', 0)
+	for i, r := range o.rs {
+		if includeHeader {
+			if i > 0 {
+				fmt.Fprintf(tw, "\n")
+			}
+			fmt.Fprintf(tw, "%s:\n", r.FolderPath)
+		}
+		for _, file := range r.File {
+			info := file.GetFileInfo()
+			if o.cmd.long {
+				fmt.Fprintf(tw, "%s\t%s\t%s\n", units.ByteSize(info.FileSize), info.Modification.Format("Mon Jan 2 15:04:05 2006"), info.Path)
+			} else {
+				fmt.Fprintf(tw, "%s\n", info.Path)
+			}
+		}
+	}
+	tw.Flush()
+	return nil
+}

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

@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type mkdir struct {
+	*flags.DatastoreFlag
+
+	createParents bool
+	isNamespace   bool
+}
+
+func init() {
+	cli.Register("datastore.mkdir", &mkdir{})
+}
+
+func (cmd *mkdir) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.createParents, "p", false, "Create intermediate directories as needed")
+	f.BoolVar(&cmd.isNamespace, "namespace", false, "Return uuid of namespace created on vsan datastore")
+}
+
+func (cmd *mkdir) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *mkdir) Usage() string {
+	return "DIRECTORY"
+}
+
+func (cmd *mkdir) Run(ctx context.Context, f *flag.FlagSet) error {
+	args := f.Args()
+	if len(args) == 0 {
+		return errors.New("missing operand")
+	}
+
+	c, err := cmd.Client()
+	if err != nil {
+		return err
+	}
+
+	if cmd.isNamespace {
+		var uuid string
+		var ds *object.Datastore
+
+		if ds, err = cmd.Datastore(); err != nil {
+			return err
+		}
+
+		path := args[0]
+
+		nm := object.NewDatastoreNamespaceManager(c)
+		if uuid, err = nm.CreateDirectory(ctx, ds, path, ""); err != nil {
+			return err
+		}
+
+		fmt.Println(uuid)
+	} else {
+		var dc *object.Datacenter
+		var path string
+
+		dc, err = cmd.Datacenter()
+		if err != nil {
+			return err
+		}
+
+		path, err = cmd.DatastorePath(args[0])
+		if err != nil {
+			return err
+		}
+
+		m := object.NewFileManager(c)
+		err = m.MakeDirectory(ctx, path, dc, cmd.createParents)
+
+		// ignore EEXIST if -p flag is given
+		if err != nil && cmd.createParents {
+			if soap.IsSoapFault(err) {
+				soapFault := soap.ToSoapFault(err)
+				if _, ok := soapFault.VimFault().(types.FileAlreadyExists); ok {
+					return nil
+				}
+			}
+		}
+	}
+
+	return err
+}

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

@@ -0,0 +1,100 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"errors"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+)
+
+type mv struct {
+	*flags.DatastoreFlag
+
+	force bool
+}
+
+func init() {
+	cli.Register("datastore.mv", &mv{})
+}
+
+func (cmd *mv) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.force, "f", false, "If true, overwrite any identically named file at the destination")
+}
+
+func (cmd *mv) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *mv) Usage() string {
+	return "SRC DST"
+}
+
+func (cmd *mv) Description() string {
+	return `Move SRC to DST on DATASTORE.
+
+Examples:
+  govc datastore.mv foo/foo.vmx foo/foo.vmx.old
+  govc datastore.mv -f my.vmx foo/foo.vmx`
+}
+
+func (cmd *mv) Run(ctx context.Context, f *flag.FlagSet) error {
+	args := f.Args()
+	if len(args) != 2 {
+		return errors.New("SRC and DST arguments are required")
+	}
+
+	c, err := cmd.Client()
+	if err != nil {
+		return err
+	}
+
+	dc, err := cmd.Datacenter()
+	if err != nil {
+		return err
+	}
+
+	// TODO: support cross-datacenter move
+
+	src, err := cmd.DatastorePath(args[0])
+	if err != nil {
+		return err
+	}
+
+	dst, err := cmd.DatastorePath(args[1])
+	if err != nil {
+		return err
+	}
+
+	m := object.NewFileManager(c)
+	task, err := m.MoveDatastoreFile(ctx, src, dc, dst, dc, cmd.force)
+	if err != nil {
+		return err
+	}
+
+	return task.Wait(ctx)
+}

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

@@ -0,0 +1,90 @@
+/*
+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 datastore
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+)
+
+type remove struct {
+	*flags.HostSystemFlag
+	*flags.DatastoreFlag
+}
+
+func init() {
+	cli.Register("datastore.remove", &remove{})
+}
+
+func (cmd *remove) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
+	cmd.HostSystemFlag.Register(ctx, f)
+
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+}
+
+func (cmd *remove) Process(ctx context.Context) error {
+	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *remove) Usage() string {
+	return "HOST..."
+}
+
+func (cmd *remove) Description() string {
+	return `Remove datastore from HOST.
+
+Examples:
+  govc datastore.remove -ds nfsDatastore cluster1
+  govc datastore.remove -ds nasDatastore host1 host2 host3`
+}
+
+func (cmd *remove) Run(ctx context.Context, f *flag.FlagSet) error {
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	hosts, err := cmd.HostSystems(f.Args())
+	if err != nil {
+		return err
+	}
+
+	for _, host := range hosts {
+		hds, err := host.ConfigManager().DatastoreSystem(ctx)
+		if err != nil {
+			return err
+		}
+
+		err = hds.Remove(ctx, ds)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

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

@@ -0,0 +1,117 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type rm struct {
+	*flags.DatastoreFlag
+
+	kind        bool
+	force       bool
+	isNamespace bool
+}
+
+func init() {
+	cli.Register("datastore.rm", &rm{})
+	cli.Alias("datastore.rm", "datastore.delete")
+}
+
+func (cmd *rm) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.kind, "t", true, "Use file type to choose disk or file manager")
+	f.BoolVar(&cmd.force, "f", false, "Force; ignore nonexistent files and arguments")
+	f.BoolVar(&cmd.isNamespace, "namespace", false, "Path is uuid of namespace on vsan datastore")
+}
+
+func (cmd *rm) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *rm) Usage() string {
+	return "FILE"
+}
+
+func (cmd *rm) Description() string {
+	return `Remove FILE from DATASTORE.
+
+Examples:
+  govc datastore.rm vm/vmware.log
+  govc datastore.rm vm
+  govc datastore.rm -f images/base.vmdk`
+}
+
+func (cmd *rm) Run(ctx context.Context, f *flag.FlagSet) error {
+	args := f.Args()
+	if len(args) == 0 {
+		return flag.ErrHelp
+	}
+
+	c, err := cmd.Client()
+	if err != nil {
+		return err
+	}
+
+	var dc *object.Datacenter
+	dc, err = cmd.Datacenter()
+	if err != nil {
+		return err
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	if cmd.isNamespace {
+		path := args[0]
+
+		nm := object.NewDatastoreNamespaceManager(c)
+		err = nm.DeleteDirectory(ctx, dc, path)
+	} else {
+		fm := ds.NewFileManager(dc, cmd.force)
+
+		remove := fm.DeleteFile // File delete
+		if cmd.kind {
+			remove = fm.Delete // VirtualDisk or File delete
+		}
+
+		err = remove(ctx, args[0])
+	}
+
+	if err != nil {
+		if types.IsFileNotFound(err) && cmd.force {
+			// Ignore error
+			return nil
+		}
+	}
+
+	return err
+}

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

@@ -0,0 +1,135 @@
+/*
+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 datastore
+
+import (
+	"context"
+	"flag"
+	"io"
+	"os"
+	"time"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+)
+
+type tail struct {
+	*flags.DatastoreFlag
+	*flags.HostSystemFlag
+
+	count  int64
+	lines  int
+	follow bool
+}
+
+func init() {
+	cli.Register("datastore.tail", &tail{})
+}
+
+func (cmd *tail) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
+	cmd.HostSystemFlag.Register(ctx, f)
+
+	f.Int64Var(&cmd.count, "c", -1, "Output the last NUM bytes")
+	f.IntVar(&cmd.lines, "n", 10, "Output the last NUM lines")
+	f.BoolVar(&cmd.follow, "f", false, "Output appended data as the file grows")
+}
+
+func (cmd *tail) Description() string {
+	return `Output the last part of datastore files.
+
+Examples:
+  govc datastore.tail -n 100 vm-name/vmware.log
+  govc datastore.tail -n 0 -f vm-name/vmware.log`
+}
+
+func (cmd *tail) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *tail) Usage() string {
+	return "PATH"
+}
+
+func (cmd *tail) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 1 {
+		return flag.ErrHelp
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	h, err := cmd.HostSystemIfSpecified()
+	if err != nil {
+		return err
+	}
+
+	if h != nil {
+		ctx = ds.HostContext(ctx, h)
+	}
+
+	file, err := ds.Open(ctx, f.Arg(0))
+	if err != nil {
+		return err
+	}
+
+	var reader io.ReadCloser = file
+
+	var offset int64
+
+	if cmd.count >= 0 {
+		info, serr := file.Stat()
+		if serr != nil {
+			return serr
+		}
+
+		if info.Size() > cmd.count {
+			offset = info.Size() - cmd.count
+
+			_, err = file.Seek(offset, io.SeekStart)
+			if err != nil {
+				return err
+			}
+		}
+	} else if cmd.lines >= 0 {
+		err = file.Tail(cmd.lines)
+		if err != nil {
+			return err
+		}
+	}
+
+	if cmd.follow {
+		reader = file.Follow(time.Second)
+	}
+
+	_, err = io.Copy(os.Stdout, reader)
+
+	_ = reader.Close()
+
+	return err
+}

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

@@ -0,0 +1,98 @@
+/*
+Copyright (c) 2014-2015 VMware, Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package datastore
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"os"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type upload struct {
+	*flags.OutputFlag
+	*flags.DatastoreFlag
+}
+
+func init() {
+	cli.Register("datastore.upload", &upload{})
+}
+
+func (cmd *upload) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
+	cmd.OutputFlag.Register(ctx, f)
+
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+}
+
+func (cmd *upload) Process(ctx context.Context) error {
+	if err := cmd.OutputFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *upload) Usage() string {
+	return "SOURCE DEST"
+}
+
+func (cmd *upload) Description() string {
+	return `Copy SOURCE from the local system to DEST on DS.
+
+If SOURCE name is "-", read source from stdin.
+
+Examples:
+  govc datastore.upload -ds datastore1 ./config.iso vm-name/config.iso
+  genisoimage ... | govc datastore.upload -ds datastore1 - vm-name/config.iso`
+}
+
+func (cmd *upload) Run(ctx context.Context, f *flag.FlagSet) error {
+	args := f.Args()
+	if len(args) != 2 {
+		return errors.New("invalid arguments")
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	p := soap.DefaultUpload
+
+	src := args[0]
+	dst := args[1]
+
+	if src == "-" {
+		return ds.Upload(ctx, os.Stdin, dst, &p)
+	}
+
+	if cmd.OutputFlag.TTY {
+		logger := cmd.ProgressLogger("Uploading... ")
+		p.Progress = logger
+		defer logger.Wait()
+	}
+
+	return ds.UploadFile(ctx, src, dst, &p)
+}

vendor/github.com/vmware/govmomi/govc/datastore/vsan/ls.go

@@ -0,0 +1,156 @@
+/*
+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 vsan
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"net/url"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+	"github.com/vmware/govmomi/vim25/mo"
+)
+
+type ls struct {
+	*flags.DatastoreFlag
+
+	long   bool
+	orphan bool
+}
+
+func init() {
+	cli.Register("datastore.vsan.dom.ls", &ls{})
+}
+
+func (cmd *ls) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.long, "l", false, "Long listing")
+	f.BoolVar(&cmd.orphan, "o", false, "List orphan objects")
+}
+
+func (cmd *ls) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *ls) Usage() string {
+	return "[UUID]..."
+}
+
+func (cmd *ls) Description() string {
+	return `List vSAN DOM objects in DS.
+
+Examples:
+  govc datastore.vsan.dom.ls
+  govc datastore.vsan.dom.ls -ds vsanDatastore -l
+  govc datastore.vsan.dom.ls -l d85aa758-63f5-500a-3150-0200308e589c`
+}
+
+func (cmd *ls) Run(ctx context.Context, f *flag.FlagSet) error {
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	var mds mo.Datastore
+	err = ds.Properties(ctx, ds.Reference(), []string{"summary"}, &mds)
+	if err != nil {
+		return err
+	}
+
+	if mds.Summary.Type != "vsan" {
+		return flag.ErrHelp
+	}
+
+	hosts, err := ds.AttachedHosts(ctx)
+	if err != nil {
+		return err
+	}
+
+	if len(hosts) == 0 {
+		return flag.ErrHelp
+	}
+
+	m, err := hosts[0].ConfigManager().VsanInternalSystem(ctx)
+	if err != nil {
+		return err
+	}
+
+	ids, err := m.QueryVsanObjectUuidsByFilter(ctx, f.Args(), 0, 0)
+	if err != nil {
+		return err
+	}
+
+	if len(ids) == 0 {
+		return nil
+	}
+
+	if !cmd.long && !cmd.orphan {
+		for _, id := range ids {
+			fmt.Fprintln(cmd.Out, id)
+		}
+
+		return nil
+	}
+
+	objs, err := m.GetVsanObjExtAttrs(ctx, ids)
+	if err != nil {
+		return err
+	}
+
+	u, err := url.Parse(mds.Summary.Url)
+	if err != nil {
+		return err
+	}
+
+	tw := tabwriter.NewWriter(cmd.Out, 2, 0, 2, ' ', 0)
+	cmd.Out = tw
+
+	for id, obj := range objs {
+		path := obj.DatastorePath(u.Path)
+
+		if cmd.orphan {
+			_, err = ds.Stat(ctx, path)
+			if err == nil {
+				continue
+			}
+
+			switch err.(type) {
+			case object.DatastoreNoSuchDirectoryError, object.DatastoreNoSuchFileError:
+			default:
+				return err
+			}
+
+			if !cmd.long {
+				fmt.Fprintln(cmd.Out, id)
+				continue
+			}
+		}
+
+		fmt.Fprintf(cmd.Out, "%s\t%s\t%s\n", id, obj.Class, path)
+	}
+
+	return tw.Flush()
+}

vendor/github.com/vmware/govmomi/govc/datastore/vsan/rm.go

@@ -0,0 +1,108 @@
+/*
+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 vsan
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+)
+
+type rm struct {
+	*flags.DatastoreFlag
+
+	force   bool
+	verbose bool
+}
+
+func init() {
+	cli.Register("datastore.vsan.dom.rm", &rm{})
+}
+
+func (cmd *rm) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
+	cmd.DatastoreFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.force, "f", false, "Force delete")
+	f.BoolVar(&cmd.verbose, "v", false, "Print deleted UUIDs to stdout, failed to stderr")
+}
+
+func (cmd *rm) Process(ctx context.Context) error {
+	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *rm) Usage() string {
+	return "UUID..."
+}
+
+func (cmd *rm) Description() string {
+	return `Remove vSAN DOM objects in DS.
+
+Examples:
+  govc datastore.vsan.dom.rm d85aa758-63f5-500a-3150-0200308e589c
+  govc datastore.vsan.dom.rm -f d85aa758-63f5-500a-3150-0200308e589c
+  govc datastore.vsan.dom.ls -o | xargs govc datastore.vsan.dom.rm`
+}
+
+func (cmd *rm) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() == 0 {
+		return flag.ErrHelp
+	}
+
+	ds, err := cmd.Datastore()
+	if err != nil {
+		return err
+	}
+
+	hosts, err := ds.AttachedHosts(ctx)
+	if err != nil {
+		return err
+	}
+
+	if len(hosts) == 0 {
+		return flag.ErrHelp
+	}
+
+	m, err := hosts[0].ConfigManager().VsanInternalSystem(ctx)
+	if err != nil {
+		return err
+	}
+
+	res, err := m.DeleteVsanObjects(ctx, f.Args(), &cmd.force)
+	if err != nil {
+		return err
+	}
+
+	if cmd.verbose {
+		for _, r := range res {
+			if r.Success {
+				fmt.Fprintln(cmd.Out, r.Uuid)
+			} else {
+				fmt.Fprintf(os.Stderr, "%s %s\n", r.Uuid, r.FailureReason[0].Message)
+			}
+		}
+	}
+
+	return nil
+}