github.com/vmware/govmomi@v0.51.0/object/host_system.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 object
     6  
     7  import (
     8  	"context"
     9  	"fmt"
    10  	"net"
    11  
    12  	"github.com/vmware/govmomi/internal"
    13  	"github.com/vmware/govmomi/vim25"
    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 HostSystem struct {
    20  	Common
    21  }
    22  
    23  func NewHostSystem(c *vim25.Client, ref types.ManagedObjectReference) *HostSystem {
    24  	return &HostSystem{
    25  		Common: NewCommon(c, ref),
    26  	}
    27  }
    28  
    29  func (h HostSystem) ConfigManager() *HostConfigManager {
    30  	return NewHostConfigManager(h.c, h.Reference())
    31  }
    32  
    33  func (h HostSystem) ResourcePool(ctx context.Context) (*ResourcePool, error) {
    34  	var mh mo.HostSystem
    35  
    36  	err := h.Properties(ctx, h.Reference(), []string{"parent"}, &mh)
    37  	if err != nil {
    38  		return nil, err
    39  	}
    40  
    41  	var mcr *mo.ComputeResource
    42  	var parent any
    43  
    44  	switch mh.Parent.Type {
    45  	case "ComputeResource":
    46  		mcr = new(mo.ComputeResource)
    47  		parent = mcr
    48  	case "ClusterComputeResource":
    49  		mcc := new(mo.ClusterComputeResource)
    50  		mcr = &mcc.ComputeResource
    51  		parent = mcc
    52  	default:
    53  		return nil, fmt.Errorf("unknown host parent type: %s", mh.Parent.Type)
    54  	}
    55  
    56  	err = h.Properties(ctx, *mh.Parent, []string{"resourcePool"}, parent)
    57  	if err != nil {
    58  		return nil, err
    59  	}
    60  
    61  	pool := NewResourcePool(h.c, *mcr.ResourcePool)
    62  	return pool, nil
    63  }
    64  
    65  func (h HostSystem) ManagementIPs(ctx context.Context) ([]net.IP, error) {
    66  	var mh mo.HostSystem
    67  
    68  	err := h.Properties(ctx, h.Reference(), []string{"config.virtualNicManagerInfo.netConfig"}, &mh)
    69  	if err != nil {
    70  		return nil, err
    71  	}
    72  
    73  	config := mh.Config
    74  	if config == nil {
    75  		return nil, nil
    76  	}
    77  
    78  	info := config.VirtualNicManagerInfo
    79  	if info == nil {
    80  		return nil, nil
    81  	}
    82  
    83  	return internal.HostSystemManagementIPs(info.NetConfig), nil
    84  }
    85  
    86  func (h HostSystem) Disconnect(ctx context.Context) (*Task, error) {
    87  	req := types.DisconnectHost_Task{
    88  		This: h.Reference(),
    89  	}
    90  
    91  	res, err := methods.DisconnectHost_Task(ctx, h.c, &req)
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  
    96  	return NewTask(h.c, res.Returnval), nil
    97  }
    98  
    99  func (h HostSystem) Reconnect(ctx context.Context, cnxSpec *types.HostConnectSpec, reconnectSpec *types.HostSystemReconnectSpec) (*Task, error) {
   100  	req := types.ReconnectHost_Task{
   101  		This:          h.Reference(),
   102  		CnxSpec:       cnxSpec,
   103  		ReconnectSpec: reconnectSpec,
   104  	}
   105  
   106  	res, err := methods.ReconnectHost_Task(ctx, h.c, &req)
   107  	if err != nil {
   108  		return nil, err
   109  	}
   110  
   111  	return NewTask(h.c, res.Returnval), nil
   112  }
   113  
   114  func (h HostSystem) EnterMaintenanceMode(ctx context.Context, timeout int32, evacuate bool, spec *types.HostMaintenanceSpec) (*Task, error) {
   115  	req := types.EnterMaintenanceMode_Task{
   116  		This:                  h.Reference(),
   117  		Timeout:               timeout,
   118  		EvacuatePoweredOffVms: types.NewBool(evacuate),
   119  		MaintenanceSpec:       spec,
   120  	}
   121  
   122  	res, err := methods.EnterMaintenanceMode_Task(ctx, h.c, &req)
   123  	if err != nil {
   124  		return nil, err
   125  	}
   126  
   127  	return NewTask(h.c, res.Returnval), nil
   128  }
   129  
   130  func (h HostSystem) ExitMaintenanceMode(ctx context.Context, timeout int32) (*Task, error) {
   131  	req := types.ExitMaintenanceMode_Task{
   132  		This:    h.Reference(),
   133  		Timeout: timeout,
   134  	}
   135  
   136  	res, err := methods.ExitMaintenanceMode_Task(ctx, h.c, &req)
   137  	if err != nil {
   138  		return nil, err
   139  	}
   140  
   141  	return NewTask(h.c, res.Returnval), nil
   142  }