github.com/vmware/govmomi@v0.51.0/object/resource_pool.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  
    10  	"github.com/vmware/govmomi/nfc"
    11  	"github.com/vmware/govmomi/vim25"
    12  	"github.com/vmware/govmomi/vim25/methods"
    13  	"github.com/vmware/govmomi/vim25/mo"
    14  	"github.com/vmware/govmomi/vim25/types"
    15  )
    16  
    17  type ResourcePool struct {
    18  	Common
    19  }
    20  
    21  func NewResourcePool(c *vim25.Client, ref types.ManagedObjectReference) *ResourcePool {
    22  	return &ResourcePool{
    23  		Common: NewCommon(c, ref),
    24  	}
    25  }
    26  
    27  // Owner returns the ResourcePool owner as a ClusterComputeResource or ComputeResource.
    28  func (p ResourcePool) Owner(ctx context.Context) (Reference, error) {
    29  	var pool mo.ResourcePool
    30  
    31  	err := p.Properties(ctx, p.Reference(), []string{"owner"}, &pool)
    32  	if err != nil {
    33  		return nil, err
    34  	}
    35  
    36  	return NewReference(p.Client(), pool.Owner), nil
    37  }
    38  
    39  func (p ResourcePool) ImportVApp(ctx context.Context, spec types.BaseImportSpec, folder *Folder, host *HostSystem) (*nfc.Lease, error) {
    40  	req := types.ImportVApp{
    41  		This: p.Reference(),
    42  		Spec: spec,
    43  	}
    44  
    45  	if folder != nil {
    46  		ref := folder.Reference()
    47  		req.Folder = &ref
    48  	}
    49  
    50  	if host != nil {
    51  		ref := host.Reference()
    52  		req.Host = &ref
    53  	}
    54  
    55  	res, err := methods.ImportVApp(ctx, p.c, &req)
    56  	if err != nil {
    57  		return nil, err
    58  	}
    59  
    60  	return nfc.NewLease(p.c, res.Returnval), nil
    61  }
    62  
    63  func (p ResourcePool) Create(ctx context.Context, name string, spec types.ResourceConfigSpec) (*ResourcePool, error) {
    64  	req := types.CreateResourcePool{
    65  		This: p.Reference(),
    66  		Name: name,
    67  		Spec: spec,
    68  	}
    69  
    70  	res, err := methods.CreateResourcePool(ctx, p.c, &req)
    71  	if err != nil {
    72  		return nil, err
    73  	}
    74  
    75  	return NewResourcePool(p.c, res.Returnval), nil
    76  }
    77  
    78  func (p ResourcePool) CreateVApp(ctx context.Context, name string, resSpec types.ResourceConfigSpec, configSpec types.VAppConfigSpec, folder *Folder) (*VirtualApp, error) {
    79  	req := types.CreateVApp{
    80  		This:       p.Reference(),
    81  		Name:       name,
    82  		ResSpec:    resSpec,
    83  		ConfigSpec: configSpec,
    84  	}
    85  
    86  	if folder != nil {
    87  		ref := folder.Reference()
    88  		req.VmFolder = &ref
    89  	}
    90  
    91  	res, err := methods.CreateVApp(ctx, p.c, &req)
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  
    96  	return NewVirtualApp(p.c, res.Returnval), nil
    97  }
    98  
    99  func (p ResourcePool) UpdateConfig(ctx context.Context, name string, config *types.ResourceConfigSpec) error {
   100  	req := types.UpdateConfig{
   101  		This:   p.Reference(),
   102  		Name:   name,
   103  		Config: config,
   104  	}
   105  
   106  	if config != nil && config.Entity == nil {
   107  		ref := p.Reference()
   108  
   109  		// Create copy of config so changes won't leak back to the caller
   110  		newConfig := *config
   111  		newConfig.Entity = &ref
   112  		req.Config = &newConfig
   113  	}
   114  
   115  	_, err := methods.UpdateConfig(ctx, p.c, &req)
   116  	return err
   117  }
   118  
   119  func (p ResourcePool) DestroyChildren(ctx context.Context) error {
   120  	req := types.DestroyChildren{
   121  		This: p.Reference(),
   122  	}
   123  
   124  	_, err := methods.DestroyChildren(ctx, p.c, &req)
   125  	return err
   126  }
   127  
   128  func (p ResourcePool) Destroy(ctx context.Context) (*Task, error) {
   129  	req := types.Destroy_Task{
   130  		This: p.Reference(),
   131  	}
   132  
   133  	res, err := methods.Destroy_Task(ctx, p.c, &req)
   134  	if err != nil {
   135  		return nil, err
   136  	}
   137  
   138  	return NewTask(p.c, res.Returnval), nil
   139  }