github.com/vmware/govmomi@v0.37.1/govc/vm/migrate.go (about)

     1  /*
     2  Copyright (c) 2016 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 vm
    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  	"github.com/vmware/govmomi/vim25/types"
    28  )
    29  
    30  type migrate struct {
    31  	*flags.FolderFlag
    32  	*flags.ResourcePoolFlag
    33  	*flags.HostSystemFlag
    34  	*flags.DatastoreFlag
    35  	*flags.VirtualMachineFlag
    36  
    37  	priority types.VirtualMachineMovePriority
    38  	spec     types.VirtualMachineRelocateSpec
    39  }
    40  
    41  func init() {
    42  	cli.Register("vm.migrate", &migrate{})
    43  }
    44  
    45  func (cmd *migrate) Register(ctx context.Context, f *flag.FlagSet) {
    46  	cmd.FolderFlag, ctx = flags.NewFolderFlag(ctx)
    47  	cmd.FolderFlag.Register(ctx, f)
    48  
    49  	cmd.VirtualMachineFlag, ctx = flags.NewVirtualMachineFlag(ctx)
    50  	cmd.VirtualMachineFlag.Register(ctx, f)
    51  
    52  	cmd.ResourcePoolFlag, ctx = flags.NewResourcePoolFlag(ctx)
    53  	cmd.ResourcePoolFlag.Register(ctx, f)
    54  
    55  	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
    56  	cmd.HostSystemFlag.Register(ctx, f)
    57  
    58  	cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx)
    59  	cmd.DatastoreFlag.Register(ctx, f)
    60  
    61  	f.StringVar((*string)(&cmd.priority), "priority", string(types.VirtualMachineMovePriorityDefaultPriority), "The task priority")
    62  }
    63  
    64  func (cmd *migrate) Process(ctx context.Context) error {
    65  	if err := cmd.FolderFlag.Process(ctx); err != nil {
    66  		return err
    67  	}
    68  	if err := cmd.VirtualMachineFlag.Process(ctx); err != nil {
    69  		return err
    70  	}
    71  	if err := cmd.ResourcePoolFlag.Process(ctx); err != nil {
    72  		return err
    73  	}
    74  	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
    75  		return err
    76  	}
    77  	if err := cmd.DatastoreFlag.Process(ctx); err != nil {
    78  		return err
    79  	}
    80  
    81  	return nil
    82  }
    83  
    84  func (cmd *migrate) Usage() string {
    85  	return "VM..."
    86  }
    87  
    88  func (cmd *migrate) Description() string {
    89  	return `Migrates VM to a specific resource pool, host or datastore.
    90  
    91  Examples:
    92    govc vm.migrate -host another-host vm-1 vm-2 vm-3
    93    govc vm.migrate -pool another-pool vm-1 vm-2 vm-3
    94    govc vm.migrate -ds another-ds vm-1 vm-2 vm-3`
    95  }
    96  
    97  func (cmd *migrate) relocate(ctx context.Context, vm *object.VirtualMachine) error {
    98  	task, err := vm.Relocate(ctx, cmd.spec, cmd.priority)
    99  	if err != nil {
   100  		return err
   101  	}
   102  
   103  	logger := cmd.DatastoreFlag.ProgressLogger(fmt.Sprintf("migrating %s... ", vm.Reference()))
   104  	_, err = task.WaitForResult(ctx, logger)
   105  	if err != nil {
   106  		return err
   107  	}
   108  
   109  	logger.Wait()
   110  
   111  	return nil
   112  }
   113  
   114  func (cmd *migrate) Run(ctx context.Context, f *flag.FlagSet) error {
   115  	vms, err := cmd.VirtualMachineFlag.VirtualMachines(f.Args())
   116  	if err != nil {
   117  		return err
   118  	}
   119  
   120  	folder, err := cmd.FolderIfSpecified()
   121  	if err != nil {
   122  		return err
   123  	}
   124  
   125  	if folder != nil {
   126  		ref := folder.Reference()
   127  		cmd.spec.Folder = &ref
   128  	}
   129  
   130  	host, err := cmd.HostSystemFlag.HostSystemIfSpecified()
   131  	if err != nil {
   132  		return err
   133  	}
   134  
   135  	if host != nil {
   136  		ref := host.Reference()
   137  		cmd.spec.Host = &ref
   138  	}
   139  
   140  	pool, err := cmd.ResourcePoolFlag.ResourcePoolIfSpecified()
   141  	if err != nil {
   142  		return err
   143  	}
   144  
   145  	if pool == nil && host != nil {
   146  		pool, err = host.ResourcePool(ctx)
   147  		if err != nil {
   148  			return err
   149  		}
   150  	}
   151  
   152  	if pool != nil {
   153  		ref := pool.Reference()
   154  		cmd.spec.Pool = &ref
   155  	}
   156  
   157  	ds, err := cmd.DatastoreFlag.DatastoreIfSpecified()
   158  	if err != nil {
   159  		return err
   160  	}
   161  
   162  	if ds != nil {
   163  		ref := ds.Reference()
   164  		cmd.spec.Datastore = &ref
   165  	}
   166  
   167  	for _, vm := range vms {
   168  		err = cmd.relocate(ctx, vm)
   169  		if err != nil {
   170  			return err
   171  		}
   172  	}
   173  
   174  	return nil
   175  }