github.com/vmware/govmomi@v0.51.0/cli/host/autostart/autostart.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 autostart
     6  
     7  import (
     8  	"context"
     9  	"errors"
    10  	"flag"
    11  
    12  	"github.com/vmware/govmomi/cli/flags"
    13  	"github.com/vmware/govmomi/object"
    14  	"github.com/vmware/govmomi/vim25/methods"
    15  	"github.com/vmware/govmomi/vim25/mo"
    16  	"github.com/vmware/govmomi/vim25/types"
    17  )
    18  
    19  type AutostartFlag struct {
    20  	*flags.ClientFlag
    21  	*flags.DatacenterFlag
    22  	*flags.HostSystemFlag
    23  }
    24  
    25  func newAutostartFlag(ctx context.Context) (*AutostartFlag, context.Context) {
    26  	f := &AutostartFlag{}
    27  	f.ClientFlag, ctx = flags.NewClientFlag(ctx)
    28  	f.DatacenterFlag, ctx = flags.NewDatacenterFlag(ctx)
    29  	f.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
    30  	return f, ctx
    31  }
    32  
    33  func (f *AutostartFlag) Register(ctx context.Context, fs *flag.FlagSet) {
    34  	f.ClientFlag.Register(ctx, fs)
    35  	f.DatacenterFlag.Register(ctx, fs)
    36  	f.HostSystemFlag.Register(ctx, fs)
    37  }
    38  
    39  func (f *AutostartFlag) Process(ctx context.Context) error {
    40  	if err := f.ClientFlag.Process(ctx); err != nil {
    41  		return err
    42  	}
    43  	if err := f.DatacenterFlag.Process(ctx); err != nil {
    44  		return err
    45  	}
    46  	if err := f.HostSystemFlag.Process(ctx); err != nil {
    47  		return err
    48  	}
    49  	return nil
    50  }
    51  
    52  // VirtualMachines returns list of virtual machine objects based on the
    53  // arguments specified on the command line. This helper is defined in
    54  // flags.SearchFlag as well, but that pulls in other virtual machine flags that
    55  // are not relevant here.
    56  func (f *AutostartFlag) VirtualMachines(args []string) ([]*object.VirtualMachine, error) {
    57  	ctx := context.TODO()
    58  	if len(args) == 0 {
    59  		return nil, errors.New("no argument")
    60  	}
    61  
    62  	finder, err := f.Finder()
    63  	if err != nil {
    64  		return nil, err
    65  	}
    66  
    67  	var out []*object.VirtualMachine
    68  	for _, arg := range args {
    69  		vms, err := finder.VirtualMachineList(ctx, arg)
    70  		if err != nil {
    71  			return nil, err
    72  		}
    73  
    74  		out = append(out, vms...)
    75  	}
    76  
    77  	return out, nil
    78  }
    79  
    80  func (f *AutostartFlag) HostAutoStartManager() (*mo.HostAutoStartManager, error) {
    81  	ctx := context.TODO()
    82  	h, err := f.HostSystem()
    83  	if err != nil {
    84  		return nil, err
    85  	}
    86  
    87  	var mhs mo.HostSystem
    88  	err = h.Properties(ctx, h.Reference(), []string{"configManager.autoStartManager"}, &mhs)
    89  	if err != nil {
    90  		return nil, err
    91  	}
    92  
    93  	var mhas mo.HostAutoStartManager
    94  	err = h.Properties(ctx, *mhs.ConfigManager.AutoStartManager, nil, &mhas)
    95  	if err != nil {
    96  		return nil, err
    97  	}
    98  
    99  	return &mhas, nil
   100  }
   101  
   102  func (f *AutostartFlag) ReconfigureDefaults(template types.AutoStartDefaults) error {
   103  	ctx := context.TODO()
   104  	c, err := f.Client()
   105  	if err != nil {
   106  		return err
   107  	}
   108  
   109  	mhas, err := f.HostAutoStartManager()
   110  	if err != nil {
   111  		return err
   112  	}
   113  
   114  	req := types.ReconfigureAutostart{
   115  		This: mhas.Reference(),
   116  		Spec: types.HostAutoStartManagerConfig{
   117  			Defaults: &template,
   118  		},
   119  	}
   120  
   121  	_, err = methods.ReconfigureAutostart(ctx, c, &req)
   122  	if err != nil {
   123  		return err
   124  	}
   125  
   126  	return nil
   127  }
   128  
   129  func (f *AutostartFlag) ReconfigureVMs(args []string, template types.AutoStartPowerInfo) error {
   130  	ctx := context.TODO()
   131  	c, err := f.Client()
   132  	if err != nil {
   133  		return err
   134  	}
   135  
   136  	mhas, err := f.HostAutoStartManager()
   137  	if err != nil {
   138  		return err
   139  	}
   140  
   141  	req := types.ReconfigureAutostart{
   142  		This: mhas.Reference(),
   143  		Spec: types.HostAutoStartManagerConfig{
   144  			PowerInfo: make([]types.AutoStartPowerInfo, 0),
   145  		},
   146  	}
   147  
   148  	vms, err := f.VirtualMachines(args)
   149  	if err != nil {
   150  		return err
   151  	}
   152  
   153  	for _, vm := range vms {
   154  		pi := template
   155  		pi.Key = vm.Reference()
   156  		req.Spec.PowerInfo = append(req.Spec.PowerInfo, pi)
   157  	}
   158  
   159  	_, err = methods.ReconfigureAutostart(ctx, c, &req)
   160  	if err != nil {
   161  		return err
   162  	}
   163  
   164  	return nil
   165  }