github.com/vmware/govmomi@v0.51.0/cli/host/shutdown.go (about)

     1  // © Broadcom. All Rights Reserved.
     2  // The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package host
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  
    12  	"github.com/vmware/govmomi/cli"
    13  	"github.com/vmware/govmomi/cli/flags"
    14  	"github.com/vmware/govmomi/object"
    15  	"github.com/vmware/govmomi/vim25/methods"
    16  	"github.com/vmware/govmomi/vim25/types"
    17  )
    18  
    19  type shutdown struct {
    20  	*flags.HostSystemFlag
    21  	force  bool
    22  	reboot bool
    23  }
    24  
    25  func init() {
    26  	cli.Register("host.shutdown", &shutdown{})
    27  }
    28  
    29  func (cmd *shutdown) Register(ctx context.Context, f *flag.FlagSet) {
    30  	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
    31  	cmd.HostSystemFlag.Register(ctx, f)
    32  
    33  	f.BoolVar(&cmd.force, "f", false, "Force shutdown when host is not in maintenance mode")
    34  	f.BoolVar(&cmd.reboot, "r", false, "Reboot host")
    35  }
    36  
    37  func (cmd *shutdown) Process(ctx context.Context) error {
    38  	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
    39  		return err
    40  	}
    41  	return nil
    42  }
    43  
    44  func (cmd *shutdown) Usage() string {
    45  	return `HOST...`
    46  }
    47  
    48  func (cmd *shutdown) Description() string {
    49  	return `Shutdown HOST.`
    50  }
    51  
    52  func (cmd *shutdown) Shutdown(ctx context.Context, host *object.HostSystem) error {
    53  	req := types.ShutdownHost_Task{
    54  		This:  host.Reference(),
    55  		Force: cmd.force,
    56  	}
    57  
    58  	res, err := methods.ShutdownHost_Task(ctx, host.Client(), &req)
    59  	if err != nil {
    60  		return err
    61  	}
    62  
    63  	task := object.NewTask(host.Client(), res.Returnval)
    64  
    65  	logger := cmd.ProgressLogger(fmt.Sprintf("%s shutdown... ", host.InventoryPath))
    66  	defer logger.Wait()
    67  
    68  	_, err = task.WaitForResult(ctx, logger)
    69  	return err
    70  }
    71  
    72  func (cmd *shutdown) Reboot(ctx context.Context, host *object.HostSystem) error {
    73  	req := types.RebootHost_Task{
    74  		This:  host.Reference(),
    75  		Force: cmd.force,
    76  	}
    77  
    78  	res, err := methods.RebootHost_Task(ctx, host.Client(), &req)
    79  	if err != nil {
    80  		return err
    81  	}
    82  
    83  	task := object.NewTask(host.Client(), res.Returnval)
    84  
    85  	logger := cmd.ProgressLogger(fmt.Sprintf("%s reboot... ", host.InventoryPath))
    86  	defer logger.Wait()
    87  
    88  	_, err = task.WaitForResult(ctx, logger)
    89  	return err
    90  }
    91  
    92  func (cmd *shutdown) Run(ctx context.Context, f *flag.FlagSet) error {
    93  	hosts, err := cmd.HostSystems(f.Args())
    94  	if err != nil {
    95  		return err
    96  	}
    97  
    98  	s := cmd.Shutdown
    99  	if cmd.reboot {
   100  		s = cmd.Reboot
   101  	}
   102  
   103  	for _, host := range hosts {
   104  		err = s(ctx, host)
   105  		if err != nil {
   106  			return err
   107  		}
   108  	}
   109  
   110  	return nil
   111  }