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 VirtualDiskManager struct {
28	Common
29}
30
31func NewVirtualDiskManager(c *vim25.Client) *VirtualDiskManager {
32	m := VirtualDiskManager{
33		Common: NewCommon(c, *c.ServiceContent.VirtualDiskManager),
34	}
35
36	return &m
37}
38
39// CopyVirtualDisk copies a virtual disk, performing conversions as specified in the spec.
40func (m VirtualDiskManager) CopyVirtualDisk(
41	ctx context.Context,
42	sourceName string, sourceDatacenter *Datacenter,
43	destName string, destDatacenter *Datacenter,
44	destSpec *types.VirtualDiskSpec, force bool) (*Task, error) {
45
46	req := types.CopyVirtualDisk_Task{
47		This:       m.Reference(),
48		SourceName: sourceName,
49		DestName:   destName,
50		DestSpec:   destSpec,
51		Force:      types.NewBool(force),
52	}
53
54	if sourceDatacenter != nil {
55		ref := sourceDatacenter.Reference()
56		req.SourceDatacenter = &ref
57	}
58
59	if destDatacenter != nil {
60		ref := destDatacenter.Reference()
61		req.DestDatacenter = &ref
62	}
63
64	res, err := methods.CopyVirtualDisk_Task(ctx, m.c, &req)
65	if err != nil {
66		return nil, err
67	}
68
69	return NewTask(m.c, res.Returnval), nil
70}
71
72// CreateVirtualDisk creates a new virtual disk.
73func (m VirtualDiskManager) CreateVirtualDisk(
74	ctx context.Context,
75	name string, datacenter *Datacenter,
76	spec types.BaseVirtualDiskSpec) (*Task, error) {
77
78	req := types.CreateVirtualDisk_Task{
79		This: m.Reference(),
80		Name: name,
81		Spec: spec,
82	}
83
84	if datacenter != nil {
85		ref := datacenter.Reference()
86		req.Datacenter = &ref
87	}
88
89	res, err := methods.CreateVirtualDisk_Task(ctx, m.c, &req)
90	if err != nil {
91		return nil, err
92	}
93
94	return NewTask(m.c, res.Returnval), nil
95}
96
97// MoveVirtualDisk moves a virtual disk.
98func (m VirtualDiskManager) MoveVirtualDisk(
99	ctx context.Context,
100	sourceName string, sourceDatacenter *Datacenter,
101	destName string, destDatacenter *Datacenter,
102	force bool) (*Task, error) {
103	req := types.MoveVirtualDisk_Task{
104		This:       m.Reference(),
105		SourceName: sourceName,
106		DestName:   destName,
107		Force:      types.NewBool(force),
108	}
109
110	if sourceDatacenter != nil {
111		ref := sourceDatacenter.Reference()
112		req.SourceDatacenter = &ref
113	}
114
115	if destDatacenter != nil {
116		ref := destDatacenter.Reference()
117		req.DestDatacenter = &ref
118	}
119
120	res, err := methods.MoveVirtualDisk_Task(ctx, m.c, &req)
121	if err != nil {
122		return nil, err
123	}
124
125	return NewTask(m.c, res.Returnval), nil
126}
127
128// DeleteVirtualDisk deletes a virtual disk.
129func (m VirtualDiskManager) DeleteVirtualDisk(ctx context.Context, name string, dc *Datacenter) (*Task, error) {
130	req := types.DeleteVirtualDisk_Task{
131		This: m.Reference(),
132		Name: name,
133	}
134
135	if dc != nil {
136		ref := dc.Reference()
137		req.Datacenter = &ref
138	}
139
140	res, err := methods.DeleteVirtualDisk_Task(ctx, m.c, &req)
141	if err != nil {
142		return nil, err
143	}
144
145	return NewTask(m.c, res.Returnval), nil
146}
147
148// InflateVirtualDisk inflates a virtual disk.
149func (m VirtualDiskManager) InflateVirtualDisk(ctx context.Context, name string, dc *Datacenter) (*Task, error) {
150	req := types.InflateVirtualDisk_Task{
151		This: m.Reference(),
152		Name: name,
153	}
154
155	if dc != nil {
156		ref := dc.Reference()
157		req.Datacenter = &ref
158	}
159
160	res, err := methods.InflateVirtualDisk_Task(ctx, m.c, &req)
161	if err != nil {
162		return nil, err
163	}
164
165	return NewTask(m.c, res.Returnval), nil
166}
167
168// ShrinkVirtualDisk shrinks a virtual disk.
169func (m VirtualDiskManager) ShrinkVirtualDisk(ctx context.Context, name string, dc *Datacenter, copy *bool) (*Task, error) {
170	req := types.ShrinkVirtualDisk_Task{
171		This: m.Reference(),
172		Name: name,
173		Copy: copy,
174	}
175
176	if dc != nil {
177		ref := dc.Reference()
178		req.Datacenter = &ref
179	}
180
181	res, err := methods.ShrinkVirtualDisk_Task(ctx, m.c, &req)
182	if err != nil {
183		return nil, err
184	}
185
186	return NewTask(m.c, res.Returnval), nil
187}
188
189// Queries virtual disk uuid
190func (m VirtualDiskManager) QueryVirtualDiskUuid(ctx context.Context, name string, dc *Datacenter) (string, error) {
191	req := types.QueryVirtualDiskUuid{
192		This: m.Reference(),
193		Name: name,
194	}
195
196	if dc != nil {
197		ref := dc.Reference()
198		req.Datacenter = &ref
199	}
200
201	res, err := methods.QueryVirtualDiskUuid(ctx, m.c, &req)
202	if err != nil {
203		return "", err
204	}
205
206	if res == nil {
207		return "", nil
208	}
209
210	return res.Returnval, nil
211}
212
213func (m VirtualDiskManager) SetVirtualDiskUuid(ctx context.Context, name string, dc *Datacenter, uuid string) error {
214	req := types.SetVirtualDiskUuid{
215		This: m.Reference(),
216		Name: name,
217		Uuid: uuid,
218	}
219
220	if dc != nil {
221		ref := dc.Reference()
222		req.Datacenter = &ref
223	}
224
225	_, err := methods.SetVirtualDiskUuid(ctx, m.c, &req)
226	return err
227}
228