1/*
2Copyright (c) 2015 VMware, Inc. All Rights Reserved.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8    http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17package object
18
19import (
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
27type StorageResourceManager struct {
28	Common
29}
30
31func NewStorageResourceManager(c *vim25.Client) *StorageResourceManager {
32	sr := StorageResourceManager{
33		Common: NewCommon(c, *c.ServiceContent.StorageResourceManager),
34	}
35
36	return &sr
37}
38
39func (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
53func (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
71func (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
82func (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
100func (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
119func (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
136func (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
153func (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
167func (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}
180