github.com/vmware/govmomi@v0.51.0/object/storage_resource_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  
    10  	"github.com/vmware/govmomi/vim25"
    11  	"github.com/vmware/govmomi/vim25/methods"
    12  	"github.com/vmware/govmomi/vim25/types"
    13  )
    14  
    15  type StorageResourceManager struct {
    16  	Common
    17  }
    18  
    19  func NewStorageResourceManager(c *vim25.Client) *StorageResourceManager {
    20  	sr := StorageResourceManager{
    21  		Common: NewCommon(c, *c.ServiceContent.StorageResourceManager),
    22  	}
    23  
    24  	return &sr
    25  }
    26  
    27  func (sr StorageResourceManager) ApplyStorageDrsRecommendation(ctx context.Context, key []string) (*Task, error) {
    28  	req := types.ApplyStorageDrsRecommendation_Task{
    29  		This: sr.Reference(),
    30  		Key:  key,
    31  	}
    32  
    33  	res, err := methods.ApplyStorageDrsRecommendation_Task(ctx, sr.c, &req)
    34  	if err != nil {
    35  		return nil, err
    36  	}
    37  
    38  	return NewTask(sr.c, res.Returnval), nil
    39  }
    40  
    41  func (sr StorageResourceManager) ApplyStorageDrsRecommendationToPod(ctx context.Context, pod *StoragePod, key string) (*Task, error) {
    42  	req := types.ApplyStorageDrsRecommendationToPod_Task{
    43  		This: sr.Reference(),
    44  		Key:  key,
    45  	}
    46  
    47  	if pod != nil {
    48  		req.Pod = pod.Reference()
    49  	}
    50  
    51  	res, err := methods.ApplyStorageDrsRecommendationToPod_Task(ctx, sr.c, &req)
    52  	if err != nil {
    53  		return nil, err
    54  	}
    55  
    56  	return NewTask(sr.c, res.Returnval), nil
    57  }
    58  
    59  func (sr StorageResourceManager) CancelStorageDrsRecommendation(ctx context.Context, key []string) error {
    60  	req := types.CancelStorageDrsRecommendation{
    61  		This: sr.Reference(),
    62  		Key:  key,
    63  	}
    64  
    65  	_, err := methods.CancelStorageDrsRecommendation(ctx, sr.c, &req)
    66  
    67  	return err
    68  }
    69  
    70  func (sr StorageResourceManager) ConfigureDatastoreIORM(ctx context.Context, datastore *Datastore, spec types.StorageIORMConfigSpec, key string) (*Task, error) {
    71  	req := types.ConfigureDatastoreIORM_Task{
    72  		This: sr.Reference(),
    73  		Spec: spec,
    74  	}
    75  
    76  	if datastore != nil {
    77  		req.Datastore = datastore.Reference()
    78  	}
    79  
    80  	res, err := methods.ConfigureDatastoreIORM_Task(ctx, sr.c, &req)
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  
    85  	return NewTask(sr.c, res.Returnval), nil
    86  }
    87  
    88  func (sr StorageResourceManager) ConfigureStorageDrsForPod(ctx context.Context, pod *StoragePod, spec types.StorageDrsConfigSpec, modify bool) (*Task, error) {
    89  	req := types.ConfigureStorageDrsForPod_Task{
    90  		This:   sr.Reference(),
    91  		Spec:   spec,
    92  		Modify: modify,
    93  	}
    94  
    95  	if pod != nil {
    96  		req.Pod = pod.Reference()
    97  	}
    98  
    99  	res, err := methods.ConfigureStorageDrsForPod_Task(ctx, sr.c, &req)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  
   104  	return NewTask(sr.c, res.Returnval), nil
   105  }
   106  
   107  func (sr StorageResourceManager) QueryDatastorePerformanceSummary(ctx context.Context, datastore *Datastore) ([]types.StoragePerformanceSummary, error) {
   108  	req := types.QueryDatastorePerformanceSummary{
   109  		This: sr.Reference(),
   110  	}
   111  
   112  	if datastore != nil {
   113  		req.Datastore = datastore.Reference()
   114  	}
   115  
   116  	res, err := methods.QueryDatastorePerformanceSummary(ctx, sr.c, &req)
   117  	if err != nil {
   118  		return nil, err
   119  	}
   120  
   121  	return res.Returnval, nil
   122  }
   123  
   124  func (sr StorageResourceManager) QueryIORMConfigOption(ctx context.Context, host *HostSystem) (*types.StorageIORMConfigOption, error) {
   125  	req := types.QueryIORMConfigOption{
   126  		This: sr.Reference(),
   127  	}
   128  
   129  	if host != nil {
   130  		req.Host = host.Reference()
   131  	}
   132  
   133  	res, err := methods.QueryIORMConfigOption(ctx, sr.c, &req)
   134  	if err != nil {
   135  		return nil, err
   136  	}
   137  
   138  	return &res.Returnval, nil
   139  }
   140  
   141  func (sr StorageResourceManager) RecommendDatastores(ctx context.Context, storageSpec types.StoragePlacementSpec) (*types.StoragePlacementResult, error) {
   142  	req := types.RecommendDatastores{
   143  		This:        sr.Reference(),
   144  		StorageSpec: storageSpec,
   145  	}
   146  
   147  	res, err := methods.RecommendDatastores(ctx, sr.c, &req)
   148  	if err != nil {
   149  		return nil, err
   150  	}
   151  
   152  	return &res.Returnval, nil
   153  }
   154  
   155  func (sr StorageResourceManager) RefreshStorageDrsRecommendation(ctx context.Context, pod *StoragePod) error {
   156  	req := types.RefreshStorageDrsRecommendation{
   157  		This: sr.Reference(),
   158  	}
   159  
   160  	if pod != nil {
   161  		req.Pod = pod.Reference()
   162  	}
   163  
   164  	_, err := methods.RefreshStorageDrsRecommendation(ctx, sr.c, &req)
   165  
   166  	return err
   167  }