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