github.com/vmware/govmomi@v0.43.0/govc/host/autostart/autostart.go (about)

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