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