github.com/vmware/govmomi@v0.37.1/govc/datastore/cp.go (about)

     1  /*
     2  Copyright (c) 2014-2018 VMware, Inc. All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package datastore
    18  
    19  import (
    20  	"context"
    21  	"flag"
    22  	"fmt"
    23  
    24  	"github.com/vmware/govmomi/govc/cli"
    25  	"github.com/vmware/govmomi/govc/flags"
    26  	"github.com/vmware/govmomi/object"
    27  )
    28  
    29  type cp struct {
    30  	target
    31  }
    32  
    33  func init() {
    34  	cli.Register("datastore.cp", &cp{})
    35  }
    36  
    37  type target struct {
    38  	*flags.DatastoreFlag // The source Datastore and the default target Datastore
    39  
    40  	dc *flags.DatacenterFlag // Optionally target a different Datacenter
    41  	ds *flags.DatastoreFlag  // Optionally target a different Datastore
    42  
    43  	kind  bool
    44  	force bool
    45  }
    46  
    47  func (cmd *target) FileManager() (*object.DatastoreFileManager, error) {
    48  	dc, err := cmd.Datacenter()
    49  	if err != nil {
    50  		return nil, err
    51  	}
    52  
    53  	ds, err := cmd.Datastore()
    54  	if err != nil {
    55  		return nil, err
    56  	}
    57  
    58  	m := ds.NewFileManager(dc, cmd.force)
    59  
    60  	dc, err = cmd.dc.Datacenter()
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	m.DatacenterTarget = dc
    65  
    66  	return m, nil
    67  }
    68  
    69  func (cmd *target) Register(ctx context.Context, f *flag.FlagSet) {
    70  	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
    71  	cmd.DatastoreFlag.Register(ctx, f)
    72  
    73  	cmd.dc = &flags.DatacenterFlag{
    74  		OutputFlag: cmd.OutputFlag,
    75  		ClientFlag: cmd.ClientFlag,
    76  	}
    77  	f.StringVar(&cmd.dc.Name, "dc-target", "", "Datacenter destination (defaults to -dc)")
    78  
    79  	cmd.ds = &flags.DatastoreFlag{
    80  		DatacenterFlag: cmd.dc,
    81  	}
    82  	f.StringVar(&cmd.ds.Name, "ds-target", "", "Datastore destination (defaults to -ds)")
    83  
    84  	f.BoolVar(&cmd.kind, "t", true, "Use file type to choose disk or file manager")
    85  	f.BoolVar(&cmd.force, "f", false, "If true, overwrite any identically named file at the destination")
    86  }
    87  
    88  func (cmd *target) Process(ctx context.Context) error {
    89  	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
    90  		return err
    91  	}
    92  
    93  	if cmd.dc.Name == "" {
    94  		// Use source DC as target DC
    95  		cmd.dc = cmd.DatacenterFlag
    96  		cmd.ds.DatacenterFlag = cmd.dc
    97  	}
    98  
    99  	if cmd.ds.Name == "" {
   100  		// Use source DS as target DS
   101  		cmd.ds.Name = cmd.DatastoreFlag.Name
   102  	}
   103  
   104  	return nil
   105  }
   106  
   107  func (cmd *cp) Usage() string {
   108  	return "SRC DST"
   109  }
   110  
   111  func (cmd *cp) Description() string {
   112  	return `Copy SRC to DST on DATASTORE.
   113  
   114  Examples:
   115    govc datastore.cp foo/foo.vmx foo/foo.vmx.old
   116    govc datastore.cp -f my.vmx foo/foo.vmx
   117    govc datastore.cp disks/disk1.vmdk disks/disk2.vmdk
   118    govc datastore.cp disks/disk1.vmdk -dc-target DC2 disks/disk2.vmdk
   119    govc datastore.cp disks/disk1.vmdk -ds-target NFS-2 disks/disk2.vmdk`
   120  }
   121  
   122  func (cmd *cp) Run(ctx context.Context, f *flag.FlagSet) error {
   123  	args := f.Args()
   124  	if len(args) != 2 {
   125  		return flag.ErrHelp
   126  	}
   127  
   128  	m, err := cmd.FileManager()
   129  	if err != nil {
   130  		return err
   131  	}
   132  
   133  	src, err := cmd.DatastorePath(args[0])
   134  	if err != nil {
   135  		return err
   136  	}
   137  
   138  	dst, err := cmd.target.ds.DatastorePath(args[1])
   139  	if err != nil {
   140  		return err
   141  	}
   142  
   143  	cp := m.CopyFile
   144  	if cmd.kind {
   145  		cp = m.Copy
   146  	}
   147  
   148  	logger := cmd.ProgressLogger(fmt.Sprintf("Copying %s to %s...", src, dst))
   149  	defer logger.Wait()
   150  
   151  	return cp(m.WithProgress(ctx, logger), src, dst)
   152  }