github.com/vmware/govmomi@v0.51.0/object/host_config_manager.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  
    11  	"github.com/vmware/govmomi/vim25"
    12  	"github.com/vmware/govmomi/vim25/types"
    13  )
    14  
    15  type HostConfigManager struct {
    16  	Common
    17  }
    18  
    19  func NewHostConfigManager(c *vim25.Client, ref types.ManagedObjectReference) *HostConfigManager {
    20  	return &HostConfigManager{
    21  		Common: NewCommon(c, ref),
    22  	}
    23  }
    24  
    25  // reference returns the ManagedObjectReference for the given HostConfigManager property name.
    26  // An error is returned if the field is nil, of type ErrNotSupported if versioned is true.
    27  func (m HostConfigManager) reference(ctx context.Context, name string, versioned ...bool) (types.ManagedObjectReference, error) {
    28  	prop := "configManager." + name
    29  	var content []types.ObjectContent
    30  
    31  	err := m.Properties(ctx, m.Reference(), []string{prop}, &content)
    32  	if err != nil {
    33  		return types.ManagedObjectReference{}, err
    34  	}
    35  
    36  	for _, c := range content {
    37  		for _, p := range c.PropSet {
    38  			if p.Name != prop {
    39  				continue
    40  			}
    41  			if ref, ok := p.Val.(types.ManagedObjectReference); ok {
    42  				return ref, nil
    43  			}
    44  		}
    45  	}
    46  
    47  	err = fmt.Errorf("%s %s is nil", m.Reference(), prop)
    48  	if len(versioned) == 1 && versioned[0] {
    49  		err = ErrNotSupported
    50  	}
    51  	return types.ManagedObjectReference{}, err
    52  }
    53  
    54  func (m HostConfigManager) DatastoreSystem(ctx context.Context) (*HostDatastoreSystem, error) {
    55  	ref, err := m.reference(ctx, "datastoreSystem")
    56  	if err != nil {
    57  		return nil, err
    58  	}
    59  	return NewHostDatastoreSystem(m.c, ref), nil
    60  }
    61  
    62  func (m HostConfigManager) NetworkSystem(ctx context.Context) (*HostNetworkSystem, error) {
    63  	ref, err := m.reference(ctx, "networkSystem")
    64  	if err != nil {
    65  		return nil, err
    66  	}
    67  	return NewHostNetworkSystem(m.c, ref), nil
    68  }
    69  
    70  func (m HostConfigManager) FirewallSystem(ctx context.Context) (*HostFirewallSystem, error) {
    71  	ref, err := m.reference(ctx, "firewallSystem")
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  
    76  	return NewHostFirewallSystem(m.c, ref), nil
    77  }
    78  
    79  func (m HostConfigManager) StorageSystem(ctx context.Context) (*HostStorageSystem, error) {
    80  	ref, err := m.reference(ctx, "storageSystem")
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  	return NewHostStorageSystem(m.c, ref), nil
    85  }
    86  
    87  func (m HostConfigManager) VirtualNicManager(ctx context.Context) (*HostVirtualNicManager, error) {
    88  	ref, err := m.reference(ctx, "virtualNicManager")
    89  	if err != nil {
    90  		return nil, err
    91  	}
    92  	return NewHostVirtualNicManager(m.c, ref, m.Reference()), nil
    93  }
    94  
    95  func (m HostConfigManager) VsanSystem(ctx context.Context) (*HostVsanSystem, error) {
    96  	ref, err := m.reference(ctx, "vsanSystem", true) // Added in 5.5
    97  	if err != nil {
    98  		return nil, err
    99  	}
   100  	return NewHostVsanSystem(m.c, ref), nil
   101  }
   102  
   103  func (m HostConfigManager) VsanInternalSystem(ctx context.Context) (*HostVsanInternalSystem, error) {
   104  	ref, err := m.reference(ctx, "vsanInternalSystem", true) // Added in 5.5
   105  	if err != nil {
   106  		return nil, err
   107  	}
   108  	return NewHostVsanInternalSystem(m.c, ref), nil
   109  }
   110  
   111  func (m HostConfigManager) AccountManager(ctx context.Context) (*HostAccountManager, error) {
   112  	ref, err := m.reference(ctx, "accountManager", true) // Added in 5.5
   113  	if err != nil {
   114  		if err == ErrNotSupported {
   115  			// Versions < 5.5 can use the ServiceContent ref,
   116  			// but only when connected directly to ESX.
   117  			if m.c.ServiceContent.AccountManager == nil {
   118  				return nil, err
   119  			}
   120  			ref = *m.c.ServiceContent.AccountManager
   121  		} else {
   122  			return nil, err
   123  		}
   124  	}
   125  
   126  	return NewHostAccountManager(m.c, ref), nil
   127  }
   128  
   129  func (m HostConfigManager) OptionManager(ctx context.Context) (*OptionManager, error) {
   130  	ref, err := m.reference(ctx, "advancedOption")
   131  	if err != nil {
   132  		return nil, err
   133  	}
   134  	return NewOptionManager(m.c, ref), nil
   135  }
   136  
   137  func (m HostConfigManager) ServiceSystem(ctx context.Context) (*HostServiceSystem, error) {
   138  	ref, err := m.reference(ctx, "serviceSystem")
   139  	if err != nil {
   140  		return nil, err
   141  	}
   142  	return NewHostServiceSystem(m.c, ref), nil
   143  }
   144  
   145  func (m HostConfigManager) CertificateManager(ctx context.Context) (*HostCertificateManager, error) {
   146  	ref, err := m.reference(ctx, "certificateManager", true) // Added in 6.0
   147  	if err != nil {
   148  		return nil, err
   149  	}
   150  	return NewHostCertificateManager(m.c, ref, m.Reference()), nil
   151  }
   152  
   153  func (m HostConfigManager) DateTimeSystem(ctx context.Context) (*HostDateTimeSystem, error) {
   154  	ref, err := m.reference(ctx, "dateTimeSystem")
   155  	if err != nil {
   156  		return nil, err
   157  	}
   158  	return NewHostDateTimeSystem(m.c, ref), nil
   159  }