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