add vendoring with go dep

vendor/github.com/vmware/govmomi/govc/vm/guest/auth.go

@@ -0,0 +1,67 @@
+/*
+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 guest
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type AuthFlag struct {
+	auth types.NamePasswordAuthentication
+}
+
+func newAuthFlag(ctx context.Context) (*AuthFlag, context.Context) {
+	return &AuthFlag{}, ctx
+}
+
+func (flag *AuthFlag) String() string {
+	return fmt.Sprintf("%s:%s", flag.auth.Username, strings.Repeat("x", len(flag.auth.Password)))
+}
+
+func (flag *AuthFlag) Set(s string) error {
+	c := strings.Split(s, ":")
+	if len(c) > 0 {
+		flag.auth.Username = c[0]
+		if len(c) > 1 {
+			flag.auth.Password = c[1]
+		}
+	}
+
+	return nil
+}
+
+func (flag *AuthFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	env := "GOVC_GUEST_LOGIN"
+	value := os.Getenv(env)
+	flag.Set(value)
+	usage := fmt.Sprintf("Guest VM credentials [%s]", env)
+	f.Var(flag, "l", usage)
+}
+
+func (flag *AuthFlag) Process(ctx context.Context) error {
+	return nil
+}
+
+func (flag *AuthFlag) Auth() types.BaseGuestAuthentication {
+	return &flag.auth
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/chmod.go

@@ -0,0 +1,77 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+	"strconv"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type chmod struct {
+	*GuestFlag
+}
+
+func init() {
+	cli.Register("guest.chmod", &chmod{})
+}
+
+func (cmd *chmod) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+}
+
+func (cmd *chmod) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *chmod) Usage() string {
+	return "MODE FILE"
+}
+
+func (cmd *chmod) Description() string {
+	return `Change FILE MODE on VM.
+
+Examples:
+  govc guest.chmod -vm $name 0644 /var/log/foo.log`
+}
+
+func (cmd *chmod) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 2 {
+		return flag.ErrHelp
+	}
+
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	var attr types.GuestPosixFileAttributes
+
+	attr.Permissions, err = strconv.ParseInt(f.Arg(0), 0, 64)
+	if err != nil {
+		return err
+	}
+
+	return m.ChangeFileAttributes(ctx, cmd.Auth(), f.Arg(1), &attr)
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/chown.go

@@ -0,0 +1,96 @@
+/*
+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 guest
+
+import (
+	"context"
+	"flag"
+	"strconv"
+	"strings"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type chown struct {
+	*GuestFlag
+}
+
+func init() {
+	cli.Register("guest.chown", &chown{})
+}
+
+func (cmd *chown) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+}
+
+func (cmd *chown) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *chown) Usage() string {
+	return "UID[:GID] FILE"
+}
+
+func (cmd *chown) Description() string {
+	return `Change FILE UID and GID on VM.
+
+Examples:
+  govc guest.chown -vm $name UID[:GID] /var/log/foo.log`
+}
+
+func (cmd *chown) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 2 {
+		return flag.ErrHelp
+	}
+
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	var attr types.GuestPosixFileAttributes
+
+	ids := strings.SplitN(f.Arg(0), ":", 2)
+	if len(ids) == 0 {
+		return flag.ErrHelp
+	}
+
+	id, err := strconv.Atoi(ids[0])
+	if err != nil {
+		return err
+	}
+
+	attr.OwnerId = new(int32)
+	*attr.OwnerId = int32(id)
+
+	if len(ids) == 2 {
+		id, err = strconv.Atoi(ids[1])
+		if err != nil {
+			return err
+		}
+
+		attr.GroupId = new(int32)
+		*attr.GroupId = int32(id)
+	}
+
+	return m.ChangeFileAttributes(ctx, cmd.Auth(), f.Arg(1), &attr)
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/download.go

@@ -0,0 +1,119 @@
+/*
+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 guest
+
+import (
+	"flag"
+	"io"
+
+	"context"
+	"os"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type download struct {
+	*GuestFlag
+
+	overwrite bool
+}
+
+func init() {
+	cli.Register("guest.download", &download{})
+}
+
+func (cmd *download) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.overwrite, "f", false, "If set, the local destination file is clobbered")
+}
+
+func (cmd *download) Usage() string {
+	return "SOURCE DEST"
+}
+
+func (cmd *download) Description() string {
+	return `Copy SOURCE from the guest VM to DEST on the local system.
+
+If DEST name is "-", source is written to stdout.
+
+Examples:
+  govc guest.download -l user:pass -vm=my-vm /var/log/my.log ./local.log
+  govc guest.download -l user:pass -vm=my-vm /etc/motd -`
+}
+
+func (cmd *download) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *download) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 2 {
+		return flag.ErrHelp
+	}
+
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	src := f.Arg(0)
+	dst := f.Arg(1)
+
+	_, err = os.Stat(dst)
+	if err == nil && !cmd.overwrite {
+		return os.ErrExist
+	}
+
+	info, err := m.InitiateFileTransferFromGuest(ctx, cmd.Auth(), src)
+	if err != nil {
+		return err
+	}
+
+	u, err := cmd.ParseURL(info.Url)
+	if err != nil {
+		return err
+	}
+
+	c, err := cmd.Client()
+	if err != nil {
+		return nil
+	}
+
+	p := soap.DefaultDownload
+
+	if dst == "-" {
+		f, _, err := c.Client.Download(u, &p)
+		if err != nil {
+			return err
+		}
+		_, err = io.Copy(os.Stdout, f)
+		return err
+	}
+
+	if cmd.OutputFlag.TTY {
+		logger := cmd.ProgressLogger("Downloading... ")
+		p.Progress = logger
+		defer logger.Wait()
+	}
+
+	return c.Client.DownloadFile(dst, u, &p)
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/file_attr.go

@@ -0,0 +1,47 @@
+/*
+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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type FileAttrFlag struct {
+	types.GuestPosixFileAttributes
+}
+
+func newFileAttrFlag(ctx context.Context) (*FileAttrFlag, context.Context) {
+	return &FileAttrFlag{}, ctx
+}
+
+func (flag *FileAttrFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	f.Var(flags.NewOptionalInt32(&flag.OwnerId), "uid", "User ID")
+	f.Var(flags.NewOptionalInt32(&flag.GroupId), "gid", "Group ID")
+	f.Int64Var(&flag.Permissions, "perm", 0, "File permissions")
+}
+
+func (flag *FileAttrFlag) Process(ctx context.Context) error {
+	return nil
+}
+
+func (flag *FileAttrFlag) Attr() types.BaseGuestFileAttributes {
+	return &flag.GuestPosixFileAttributes
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/getenv.go

@@ -0,0 +1,75 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	"github.com/vmware/govmomi/govc/cli"
+)
+
+type getenv struct {
+	*GuestFlag
+}
+
+func init() {
+	cli.Register("guest.getenv", &getenv{})
+}
+
+func (cmd *getenv) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+}
+
+func (cmd *getenv) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *getenv) Usage() string {
+	return "[NAME]..."
+}
+
+func (cmd *getenv) Description() string {
+	return `Read NAME environment variables from VM.
+
+Examples:
+  govc guest.getenv -vm $name
+  govc guest.getenv -vm $name HOME`
+}
+
+func (cmd *getenv) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.ProcessManager()
+	if err != nil {
+		return err
+	}
+
+	vars, err := m.ReadEnvironmentVariable(ctx, cmd.Auth(), f.Args())
+	if err != nil {
+		return err
+	}
+
+	for _, v := range vars {
+		fmt.Printf("%s\n", v)
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/guest.go

@@ -0,0 +1,115 @@
+/*
+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 guest
+
+import (
+	"errors"
+	"flag"
+
+	"context"
+	"net/url"
+
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/guest"
+	"github.com/vmware/govmomi/object"
+)
+
+type GuestFlag struct {
+	*flags.ClientFlag
+	*flags.VirtualMachineFlag
+
+	*AuthFlag
+}
+
+func newGuestFlag(ctx context.Context) (*GuestFlag, context.Context) {
+	f := &GuestFlag{}
+	f.ClientFlag, ctx = flags.NewClientFlag(ctx)
+	f.VirtualMachineFlag, ctx = flags.NewVirtualMachineFlag(ctx)
+	f.AuthFlag, ctx = newAuthFlag(ctx)
+	return f, ctx
+}
+
+func (flag *GuestFlag) Register(ctx context.Context, f *flag.FlagSet) {
+	flag.ClientFlag.Register(ctx, f)
+	flag.VirtualMachineFlag.Register(ctx, f)
+	flag.AuthFlag.Register(ctx, f)
+}
+
+func (flag *GuestFlag) Process(ctx context.Context) error {
+	if err := flag.ClientFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := flag.VirtualMachineFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := flag.AuthFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (flag *GuestFlag) FileManager() (*guest.FileManager, error) {
+	ctx := context.TODO()
+	c, err := flag.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	vm, err := flag.VirtualMachine()
+	if err != nil {
+		return nil, err
+	}
+
+	o := guest.NewOperationsManager(c, vm.Reference())
+	return o.FileManager(ctx)
+}
+
+func (flag *GuestFlag) ProcessManager() (*guest.ProcessManager, error) {
+	ctx := context.TODO()
+	c, err := flag.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	vm, err := flag.VirtualMachine()
+	if err != nil {
+		return nil, err
+	}
+
+	o := guest.NewOperationsManager(c, vm.Reference())
+	return o.ProcessManager(ctx)
+}
+
+func (flag *GuestFlag) ParseURL(urlStr string) (*url.URL, error) {
+	c, err := flag.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	return c.Client.ParseURL(urlStr)
+}
+
+func (flag *GuestFlag) VirtualMachine() (*object.VirtualMachine, error) {
+	vm, err := flag.VirtualMachineFlag.VirtualMachine()
+	if err != nil {
+		return nil, err
+	}
+	if vm == nil {
+		return nil, errors.New("no vm specified")
+	}
+	return vm, nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/kill.go

@@ -0,0 +1,70 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+)
+
+type kill struct {
+	*GuestFlag
+
+	pids pidSelector
+}
+
+func init() {
+	cli.Register("guest.kill", &kill{})
+}
+
+func (cmd *kill) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.Var(&cmd.pids, "p", "Process ID")
+}
+
+func (cmd *kill) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *kill) Description() string {
+	return `Kill process ID on VM.
+
+Examples:
+  govc guest.kill -vm $name -p 12345`
+}
+
+func (cmd *kill) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.ProcessManager()
+	if err != nil {
+		return err
+	}
+
+	for _, pid := range cmd.pids {
+		if err := m.TerminateProcess(ctx, cmd.Auth(), pid); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/ls.go

@@ -0,0 +1,121 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/units"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ls struct {
+	*GuestFlag
+
+	simple bool
+}
+
+func init() {
+	cli.Register("guest.ls", &ls{})
+}
+
+func (cmd *ls) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.simple, "s", false, "Simple path only listing") // sadly we used '-l' for guest login
+}
+
+func (cmd *ls) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *ls) Usage() string {
+	return "PATH"
+}
+
+func (cmd *ls) Description() string {
+	return `List PATH files in VM.
+
+Examples:
+  govc guest.ls -vm $name /tmp`
+}
+
+func (cmd *ls) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	var offset int32
+	tw := tabwriter.NewWriter(os.Stdout, 2, 0, 2, ' ', 0)
+
+	for {
+		info, err := m.ListFiles(ctx, cmd.Auth(), f.Arg(0), offset, 0, f.Arg(1))
+		if err != nil {
+			return err
+		}
+
+		for _, f := range info.Files {
+			if cmd.simple {
+				fmt.Fprintln(tw, f.Path)
+				continue
+			}
+
+			var kind byte
+
+			switch types.GuestFileType(f.Type) {
+			case types.GuestFileTypeDirectory:
+				kind = 'd'
+				if f.Size == 0 {
+					f.Size = 4092
+				}
+			case types.GuestFileTypeSymlink:
+				kind = 'l'
+			case types.GuestFileTypeFile:
+				kind = '-'
+			}
+
+			switch x := f.Attributes.(type) {
+			case *types.GuestPosixFileAttributes:
+				perm := os.FileMode(x.Permissions).Perm().String()[1:]
+				fmt.Fprintf(tw, "%c%s\t%d\t%d\t", kind, perm, *x.OwnerId, *x.GroupId)
+			}
+
+			attr := f.Attributes.GetGuestFileAttributes()
+
+			fmt.Fprintf(tw, "%s\t%s\t%s\n", units.FileSize(f.Size), attr.ModificationTime.Format("Jan 2 15:04 2006"), f.Path)
+		}
+
+		_ = tw.Flush()
+
+		if info.Remaining == 0 {
+			break
+		}
+		offset += int32(len(info.Files))
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/mkdir.go

@@ -0,0 +1,83 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type mkdir struct {
+	*GuestFlag
+
+	createParents bool
+}
+
+func init() {
+	cli.Register("guest.mkdir", &mkdir{})
+}
+
+func (cmd *mkdir) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.createParents, "p", false, "Create intermediate directories as needed")
+}
+
+func (cmd *mkdir) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *mkdir) Usage() string {
+	return "PATH"
+}
+
+func (cmd *mkdir) Description() string {
+	return `Create directory PATH in VM.
+
+Examples:
+  govc guest.mkdir -vm $name /tmp/logs
+  govc guest.mkdir -vm $name -p /tmp/logs/foo/bar`
+}
+
+func (cmd *mkdir) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	err = m.MakeDirectory(ctx, cmd.Auth(), f.Arg(0), 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/vm/guest/mktemp.go

@@ -0,0 +1,86 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	"github.com/vmware/govmomi/govc/cli"
+)
+
+type mktemp struct {
+	*GuestFlag
+
+	dir    bool
+	path   string
+	prefix string
+	suffix string
+}
+
+func init() {
+	cli.Register("guest.mktemp", &mktemp{})
+}
+
+func (cmd *mktemp) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.dir, "d", false, "Make a directory instead of a file")
+	f.StringVar(&cmd.path, "p", "", "If specified, create relative to this directory")
+	f.StringVar(&cmd.prefix, "t", "", "Prefix")
+	f.StringVar(&cmd.suffix, "s", "", "Suffix")
+}
+
+func (cmd *mktemp) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *mktemp) Description() string {
+	return `Create a temporary file or directory in VM.
+
+Examples:
+  govc guest.mktemp -vm $name
+  govc guest.mktemp -vm $name -d
+  govc guest.mktemp -vm $name -t myprefix
+  govc guest.mktemp -vm $name -p /var/tmp/$USER`
+}
+
+func (cmd *mktemp) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	mk := m.CreateTemporaryFile
+	if cmd.dir {
+		mk = m.CreateTemporaryDirectory
+	}
+
+	name, err := mk(ctx, cmd.Auth(), cmd.prefix, cmd.suffix, cmd.path)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(name)
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/mv.go

@@ -0,0 +1,85 @@
+/*
+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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type mv struct {
+	*GuestFlag
+
+	noclobber bool
+}
+
+func init() {
+	cli.Register("guest.mv", &mv{})
+}
+
+func (cmd *mv) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.noclobber, "n", false, "Do not overwrite an existing file")
+}
+
+func (cmd *mv) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *mv) Usage() string {
+	return "SOURCE DEST"
+}
+
+func (cmd *mv) Description() string {
+	return `Move (rename) files in VM.
+
+Examples:
+  govc guest.mv -vm $name /tmp/foo.sh /tmp/bar.sh
+  govc guest.mv -vm $name -n /tmp/baz.sh /tmp/bar.sh`
+}
+
+func (cmd *mv) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	src := f.Arg(0)
+	dst := f.Arg(1)
+
+	err = m.MoveFile(ctx, cmd.Auth(), src, dst, !cmd.noclobber)
+
+	if err != nil {
+		if soap.IsSoapFault(err) {
+			soapFault := soap.ToSoapFault(err)
+			if _, ok := soapFault.VimFault().(types.NotAFile); ok {
+				err = m.MoveDirectory(ctx, cmd.Auth(), src, dst)
+			}
+		}
+	}
+
+	return err
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/ps.go

@@ -0,0 +1,199 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type ps struct {
+	*flags.OutputFlag
+	*GuestFlag
+
+	every bool
+	exit  bool
+	wait  bool
+
+	pids pidSelector
+	uids uidSelector
+}
+
+type pidSelector []int64
+
+func (s *pidSelector) String() string {
+	return fmt.Sprint(*s)
+}
+
+func (s *pidSelector) Set(value string) error {
+	v, err := strconv.ParseInt(value, 0, 64)
+	if err != nil {
+		return err
+	}
+	*s = append(*s, v)
+	return nil
+}
+
+type uidSelector map[string]bool
+
+func (s uidSelector) String() string {
+	return ""
+}
+
+func (s uidSelector) Set(value string) error {
+	s[value] = true
+	return nil
+}
+
+func init() {
+	cli.Register("guest.ps", &ps{})
+}
+
+func (cmd *ps) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.OutputFlag, ctx = flags.NewOutputFlag(ctx)
+	cmd.OutputFlag.Register(ctx, f)
+
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	cmd.uids = make(map[string]bool)
+	f.BoolVar(&cmd.every, "e", false, "Select all processes")
+	f.BoolVar(&cmd.exit, "x", false, "Output exit time and code")
+	f.BoolVar(&cmd.wait, "X", false, "Wait for process to exit")
+	f.Var(&cmd.pids, "p", "Select by process ID")
+	f.Var(&cmd.uids, "U", "Select by process UID")
+}
+
+func (cmd *ps) Process(ctx context.Context) error {
+	if err := cmd.OutputFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *ps) Description() string {
+	return `List processes in VM.
+
+By default, unless the '-e', '-p' or '-U' flag is specified, only processes owned
+by the '-l' flag user are displayed.
+
+The '-x' and '-X' flags only apply to processes started by vmware-tools,
+such as those started with the govc guest.start command.
+
+Examples:
+  govc guest.ps -vm $name
+  govc guest.ps -vm $name -e
+  govc guest.ps -vm $name -p 12345
+  govc guest.ps -vm $name -U root`
+}
+
+func running(procs []types.GuestProcessInfo) bool {
+	for _, p := range procs {
+		if p.EndTime == nil {
+			return true
+		}
+	}
+	return false
+}
+
+func (cmd *ps) list(ctx context.Context) ([]types.GuestProcessInfo, error) {
+	m, err := cmd.ProcessManager()
+	if err != nil {
+		return nil, err
+	}
+
+	auth := cmd.Auth()
+
+	for {
+		procs, err := m.ListProcesses(ctx, auth, cmd.pids)
+		if err != nil {
+			return nil, err
+		}
+
+		if cmd.wait && running(procs) {
+			<-time.After(time.Millisecond * 250)
+			continue
+		}
+
+		return procs, nil
+	}
+}
+
+func (cmd *ps) Run(ctx context.Context, f *flag.FlagSet) error {
+	procs, err := cmd.list(ctx)
+	if err != nil {
+		return err
+	}
+
+	r := &psResult{cmd, procs}
+
+	return cmd.WriteResult(r)
+}
+
+type psResult struct {
+	cmd         *ps
+	ProcessInfo []types.GuestProcessInfo
+}
+
+func (r *psResult) Write(w io.Writer) error {
+	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
+
+	fmt.Fprintf(tw, "%s\t%s\t%s", "UID", "PID", "STIME")
+	if r.cmd.exit {
+		fmt.Fprintf(tw, "\t%s\t%s", "XTIME", "XCODE")
+	}
+	fmt.Fprint(tw, "\tCMD\n")
+
+	if len(r.cmd.pids) != 0 {
+		r.cmd.every = true
+	}
+
+	if !r.cmd.every && len(r.cmd.uids) == 0 {
+		r.cmd.uids[r.cmd.auth.Username] = true
+	}
+
+	for _, p := range r.ProcessInfo {
+		if r.cmd.every || r.cmd.uids[p.Owner] {
+			fmt.Fprintf(tw, "%s\t%d\t%s", p.Owner, p.Pid, p.StartTime.Format("15:04"))
+			if r.cmd.exit {
+				etime := "-"
+				ecode := "-"
+				if p.EndTime != nil {
+					etime = p.EndTime.Format("15:04")
+					ecode = strconv.Itoa(int(p.ExitCode))
+				}
+				fmt.Fprintf(tw, "\t%s\t%s", etime, ecode)
+			}
+			fmt.Fprintf(tw, "\t%s\n", strings.TrimSpace(p.CmdLine))
+		}
+	}
+
+	return tw.Flush()
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/rm.go

@@ -0,0 +1,64 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+)
+
+type rm struct {
+	*GuestFlag
+}
+
+func init() {
+	cli.Register("guest.rm", &rm{})
+}
+
+func (cmd *rm) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+}
+
+func (cmd *rm) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *rm) Usage() string {
+	return "PATH"
+}
+
+func (cmd *rm) Description() string {
+	return `Remove file PATH in VM.
+
+Examples:
+  govc guest.rm -vm $name /tmp/foo.log`
+}
+
+func (cmd *rm) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	return m.DeleteFile(ctx, cmd.Auth(), f.Arg(0))
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/rmdir.go

@@ -0,0 +1,69 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+)
+
+type rmdir struct {
+	*GuestFlag
+
+	recursive bool
+}
+
+func init() {
+	cli.Register("guest.rmdir", &rmdir{})
+}
+
+func (cmd *rmdir) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.recursive, "r", false, "Recursive removal")
+}
+
+func (cmd *rmdir) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *rmdir) Usage() string {
+	return "PATH"
+}
+
+func (cmd *rmdir) Description() string {
+	return `Remove directory PATH in VM.
+
+Examples:
+  govc guest.rmdir -vm $name /tmp/empty-dir
+  govc guest.rmdir -vm $name -r /tmp/non-empty-dir`
+}
+
+func (cmd *rmdir) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	return m.DeleteDirectory(ctx, cmd.Auth(), f.Arg(0), cmd.recursive)
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/start.go

@@ -0,0 +1,103 @@
+/*
+Copyright (c) 2014-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 guest
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type start struct {
+	*GuestFlag
+
+	dir  string
+	vars env
+}
+
+type env []string
+
+func (e *env) String() string {
+	return fmt.Sprint(*e)
+}
+
+func (e *env) Set(value string) error {
+	*e = append(*e, value)
+	return nil
+}
+
+func init() {
+	cli.Register("guest.start", &start{})
+}
+
+func (cmd *start) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.StringVar(&cmd.dir, "C", "", "The absolute path of the working directory for the program to start")
+	f.Var(&cmd.vars, "e", "Set environment variable (key=val)")
+}
+
+func (cmd *start) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *start) Usage() string {
+	return "PATH [ARG]..."
+}
+
+func (cmd *start) Description() string {
+	return `Start program in VM.
+
+The process can have its status queried with govc guest.ps.
+When the process completes, its exit code and end time will be available for 5 minutes after completion.
+
+Examples:
+  govc guest.start -vm $name /bin/mount /dev/hdb1 /data
+  pid=$(govc guest.start -vm $name /bin/long-running-thing)
+  govc guest.ps -vm $name -p $pid -X`
+}
+
+func (cmd *start) Run(ctx context.Context, f *flag.FlagSet) error {
+	m, err := cmd.ProcessManager()
+	if err != nil {
+		return err
+	}
+
+	spec := types.GuestProgramSpec{
+		ProgramPath:      f.Arg(0),
+		Arguments:        strings.Join(f.Args()[1:], " "),
+		WorkingDirectory: cmd.dir,
+		EnvVariables:     cmd.vars,
+	}
+
+	pid, err := m.StartProgram(ctx, cmd.Auth(), &spec)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("%d\n", pid)
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/tools.go

@@ -0,0 +1,116 @@
+/*
+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 guest
+
+import (
+	"context"
+	"flag"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/govc/flags"
+	"github.com/vmware/govmomi/object"
+)
+
+type tools struct {
+	*flags.ClientFlag
+	*flags.SearchFlag
+
+	mount   bool
+	upgrade bool
+	options string
+	unmount bool
+}
+
+func init() {
+	cli.Register("vm.guest.tools", &tools{})
+}
+
+func (cmd *tools) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.ClientFlag, ctx = flags.NewClientFlag(ctx)
+	cmd.ClientFlag.Register(ctx, f)
+
+	cmd.SearchFlag, ctx = flags.NewSearchFlag(ctx, flags.SearchVirtualMachines)
+	cmd.SearchFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.mount, "mount", false, "Mount tools CD installer in the guest")
+	f.BoolVar(&cmd.upgrade, "upgrade", false, "Upgrade tools in the guest")
+	f.StringVar(&cmd.options, "options", "", "Installer options")
+	f.BoolVar(&cmd.unmount, "unmount", false, "Unmount tools CD installer in the guest")
+}
+
+func (cmd *tools) Process(ctx context.Context) error {
+	if err := cmd.ClientFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.SearchFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *tools) Usage() string {
+	return "VM..."
+}
+
+func (cmd *tools) Description() string {
+	return `Manage guest tools in VM.
+
+Examples:
+  govc vm.guest.tools -mount VM
+  govc vm.guest.tools -unmount VM
+  govc vm.guest.tools -upgrade -options "opt1 opt2" VM`
+}
+
+func (cmd *tools) Upgrade(ctx context.Context, vm *object.VirtualMachine) error {
+	task, err := vm.UpgradeTools(ctx, cmd.options)
+	if err != nil {
+		return err
+	}
+
+	return task.Wait(ctx)
+}
+
+func (cmd *tools) Run(ctx context.Context, f *flag.FlagSet) error {
+	vms, err := cmd.VirtualMachines(f.Args())
+	if err != nil {
+		return err
+	}
+
+	for _, vm := range vms {
+		switch {
+		case cmd.mount:
+			err = vm.MountToolsInstaller(ctx)
+			if err != nil {
+				return err
+			}
+		case cmd.upgrade:
+			err = cmd.Upgrade(ctx, vm)
+			if err != nil {
+				return err
+			}
+		case cmd.unmount:
+			err = vm.UnmountToolsInstaller(ctx)
+			if err != nil {
+				return err
+			}
+		default:
+			return flag.ErrHelp
+		}
+	}
+
+	return nil
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/touch.go

@@ -0,0 +1,126 @@
+/*
+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 guest
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"time"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/soap"
+	"github.com/vmware/govmomi/vim25/types"
+)
+
+type touch struct {
+	*GuestFlag
+
+	nocreate bool
+	atime    bool
+	date     string
+}
+
+func init() {
+	cli.Register("guest.touch", &touch{})
+}
+
+func (cmd *touch) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.atime, "a", false, "Change only the access time")
+	f.BoolVar(&cmd.nocreate, "c", false, "Do not create any files")
+	f.StringVar(&cmd.date, "d", "", "Use DATE instead of current time")
+}
+
+func (cmd *touch) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *touch) Usage() string {
+	return "FILE"
+}
+
+func (cmd *touch) Description() string {
+	return `Change FILE times on VM.
+
+Examples:
+  govc guest.touch -vm $name /var/log/foo.log
+  govc guest.touch -vm $name -d "$(date -d '1 day ago')" /var/log/foo.log`
+}
+
+func (cmd *touch) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 1 {
+		return flag.ErrHelp
+	}
+
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	name := f.Arg(0)
+
+	var attr types.GuestFileAttributes
+	now := time.Now()
+
+	if cmd.date != "" {
+		now, err = time.Parse(time.UnixDate, cmd.date)
+		if err != nil {
+			return err
+		}
+	}
+
+	if cmd.atime {
+		attr.AccessTime = &now
+	} else {
+		attr.ModificationTime = &now
+	}
+
+	err = m.ChangeFileAttributes(ctx, cmd.Auth(), name, &attr)
+	if err != nil && !cmd.nocreate && soap.IsSoapFault(err) {
+		fault := soap.ToSoapFault(err)
+		if _, ok := fault.VimFault().(types.FileNotFound); ok {
+			// create a new empty file
+			url, cerr := m.InitiateFileTransferToGuest(ctx, cmd.Auth(), name, &attr, 0, false)
+			if cerr != nil {
+				return cerr
+			}
+
+			u, cerr := cmd.ParseURL(url)
+			if cerr != nil {
+				return cerr
+			}
+
+			c, cerr := cmd.Client()
+			if cerr != nil {
+				return cerr
+			}
+
+			err = c.Client.Upload(new(bytes.Buffer), u, &soap.DefaultUpload)
+			if err == nil && cmd.date != "" {
+				err = m.ChangeFileAttributes(ctx, cmd.Auth(), name, &attr)
+			}
+		}
+	}
+
+	return err
+}

vendor/github.com/vmware/govmomi/govc/vm/guest/upload.go

@@ -0,0 +1,133 @@
+/*
+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 guest
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"io"
+	"os"
+
+	"github.com/vmware/govmomi/govc/cli"
+	"github.com/vmware/govmomi/vim25/soap"
+)
+
+type upload struct {
+	*GuestFlag
+	*FileAttrFlag
+
+	overwrite bool
+}
+
+func init() {
+	cli.Register("guest.upload", &upload{})
+}
+
+func (cmd *upload) Register(ctx context.Context, f *flag.FlagSet) {
+	cmd.GuestFlag, ctx = newGuestFlag(ctx)
+	cmd.GuestFlag.Register(ctx, f)
+	cmd.FileAttrFlag, ctx = newFileAttrFlag(ctx)
+	cmd.FileAttrFlag.Register(ctx, f)
+
+	f.BoolVar(&cmd.overwrite, "f", false, "If set, the guest destination file is clobbered")
+}
+
+func (cmd *upload) Usage() string {
+	return "SOURCE DEST"
+}
+
+func (cmd *upload) Description() string {
+	return `Copy SOURCE from the local system to DEST in the guest VM.
+
+If SOURCE name is "-", read source from stdin.
+
+Examples:
+  govc guest.upload -l user:pass -vm=my-vm ~/.ssh/id_rsa.pub /home/$USER/.ssh/authorized_keys
+  cowsay "have a great day" | govc guest.upload -l user:pass -vm=my-vm - /etc/motd`
+}
+
+func (cmd *upload) Process(ctx context.Context) error {
+	if err := cmd.GuestFlag.Process(ctx); err != nil {
+		return err
+	}
+	if err := cmd.FileAttrFlag.Process(ctx); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (cmd *upload) Run(ctx context.Context, f *flag.FlagSet) error {
+	if f.NArg() != 2 {
+		return flag.ErrHelp
+	}
+
+	m, err := cmd.FileManager()
+	if err != nil {
+		return err
+	}
+
+	src := f.Arg(0)
+	dst := f.Arg(1)
+
+	var size int64
+	var buf *bytes.Buffer
+
+	if src == "-" {
+		buf = new(bytes.Buffer)
+		size, err = io.Copy(buf, os.Stdin)
+		if err != nil {
+			return err
+		}
+	} else {
+		s, err := os.Stat(src)
+		if err != nil {
+			return err
+		}
+		size = s.Size()
+	}
+
+	url, err := m.InitiateFileTransferToGuest(ctx, cmd.Auth(), dst, cmd.Attr(), size, cmd.overwrite)
+	if err != nil {
+		return err
+	}
+
+	u, err := cmd.ParseURL(url)
+	if err != nil {
+		return err
+	}
+
+	c, err := cmd.Client()
+	if err != nil {
+		return nil
+	}
+
+	p := soap.DefaultUpload
+
+	if buf != nil {
+		p.ContentLength = size
+		return c.Client.Upload(buf, u, &p)
+	}
+
+	if cmd.OutputFlag.TTY {
+		logger := cmd.ProgressLogger("Uploading... ")
+		p.Progress = logger
+		defer logger.Wait()
+	}
+
+	return c.Client.UploadFile(src, u, nil)
+}