1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
|
// Package v3 contains common functions for creating block storage based
// resources for use in acceptance tests. See the `*_test.go` files for
// example usages.
package v3
import (
"testing"
"github.com/gophercloud/gophercloud"
"github.com/gophercloud/gophercloud/acceptance/tools"
"github.com/gophercloud/gophercloud/openstack/blockstorage/v3/qos"
"github.com/gophercloud/gophercloud/openstack/blockstorage/v3/snapshots"
"github.com/gophercloud/gophercloud/openstack/blockstorage/v3/volumes"
"github.com/gophercloud/gophercloud/openstack/blockstorage/v3/volumetypes"
th "github.com/gophercloud/gophercloud/testhelper"
)
// CreateSnapshot will create a snapshot of the specified volume.
// Snapshot will be assigned a random name and description.
func CreateSnapshot(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) (*snapshots.Snapshot, error) {
snapshotName := tools.RandomString("ACPTTEST", 16)
snapshotDescription := tools.RandomString("ACPTTEST", 16)
t.Logf("Attempting to create snapshot: %s", snapshotName)
createOpts := snapshots.CreateOpts{
VolumeID: volume.ID,
Name: snapshotName,
Description: snapshotDescription,
}
snapshot, err := snapshots.Create(client, createOpts).Extract()
if err != nil {
return snapshot, err
}
err = snapshots.WaitForStatus(client, snapshot.ID, "available", 60)
if err != nil {
return snapshot, err
}
tools.PrintResource(t, snapshot)
th.AssertEquals(t, snapshot.Name, snapshotName)
th.AssertEquals(t, snapshot.VolumeID, volume.ID)
t.Logf("Successfully created snapshot: %s", snapshot.ID)
return snapshot, nil
}
// CreateVolume will create a volume with a random name and size of 1GB. An
// error will be returned if the volume was unable to be created.
func CreateVolume(t *testing.T, client *gophercloud.ServiceClient) (*volumes.Volume, error) {
volumeName := tools.RandomString("ACPTTEST", 16)
volumeDescription := tools.RandomString("ACPTTEST-DESC", 16)
t.Logf("Attempting to create volume: %s", volumeName)
createOpts := volumes.CreateOpts{
Size: 1,
Name: volumeName,
Description: volumeDescription,
}
volume, err := volumes.Create(client, createOpts).Extract()
if err != nil {
return volume, err
}
err = volumes.WaitForStatus(client, volume.ID, "available", 60)
if err != nil {
return volume, err
}
tools.PrintResource(t, volume)
th.AssertEquals(t, volume.Name, volumeName)
th.AssertEquals(t, volume.Description, volumeDescription)
th.AssertEquals(t, volume.Size, 1)
t.Logf("Successfully created volume: %s", volume.ID)
return volume, nil
}
// CreateVolumeWithType will create a volume of the given volume type
// with a random name and size of 1GB. An error will be returned if
// the volume was unable to be created.
func CreateVolumeWithType(t *testing.T, client *gophercloud.ServiceClient, vt *volumetypes.VolumeType) (*volumes.Volume, error) {
volumeName := tools.RandomString("ACPTTEST", 16)
volumeDescription := tools.RandomString("ACPTTEST-DESC", 16)
t.Logf("Attempting to create volume: %s", volumeName)
createOpts := volumes.CreateOpts{
Size: 1,
Name: volumeName,
Description: volumeDescription,
VolumeType: vt.Name,
}
volume, err := volumes.Create(client, createOpts).Extract()
if err != nil {
return volume, err
}
err = volumes.WaitForStatus(client, volume.ID, "available", 60)
if err != nil {
return volume, err
}
tools.PrintResource(t, volume)
th.AssertEquals(t, volume.Name, volumeName)
th.AssertEquals(t, volume.Description, volumeDescription)
th.AssertEquals(t, volume.Size, 1)
th.AssertEquals(t, volume.VolumeType, vt.Name)
t.Logf("Successfully created volume: %s", volume.ID)
return volume, nil
}
// CreateVolumeType will create a volume type with a random name. An
// error will be returned if the volume was unable to be created.
func CreateVolumeType(t *testing.T, client *gophercloud.ServiceClient) (*volumetypes.VolumeType, error) {
name := tools.RandomString("ACPTTEST", 16)
description := "create_from_gophercloud"
t.Logf("Attempting to create volume type: %s", name)
createOpts := volumetypes.CreateOpts{
Name: name,
ExtraSpecs: map[string]string{"volume_backend_name": "fake_backend_name"},
Description: description,
}
vt, err := volumetypes.Create(client, createOpts).Extract()
if err != nil {
return nil, err
}
tools.PrintResource(t, vt)
th.AssertEquals(t, vt.IsPublic, true)
th.AssertEquals(t, vt.Name, name)
th.AssertEquals(t, vt.Description, description)
// TODO: For some reason returned extra_specs are empty even in API reference: https://developer.openstack.org/api-ref/block-storage/v3/?expanded=create-a-volume-type-detail#volume-types-types
// "extra_specs": {}
// th.AssertEquals(t, vt.ExtraSpecs, createOpts.ExtraSpecs)
t.Logf("Successfully created volume type: %s", vt.ID)
return vt, nil
}
// CreateVolumeTypeNoExtraSpecs will create a volume type with a random name and
// no extra specs. This is required to bypass cinder-scheduler filters and be able
// to create a volume with this volumeType. An error will be returned if the volume
// type was unable to be created.
func CreateVolumeTypeNoExtraSpecs(t *testing.T, client *gophercloud.ServiceClient) (*volumetypes.VolumeType, error) {
name := tools.RandomString("ACPTTEST", 16)
description := "create_from_gophercloud"
t.Logf("Attempting to create volume type: %s", name)
createOpts := volumetypes.CreateOpts{
Name: name,
ExtraSpecs: map[string]string{},
Description: description,
}
vt, err := volumetypes.Create(client, createOpts).Extract()
if err != nil {
return nil, err
}
tools.PrintResource(t, vt)
th.AssertEquals(t, vt.IsPublic, true)
th.AssertEquals(t, vt.Name, name)
th.AssertEquals(t, vt.Description, description)
t.Logf("Successfully created volume type: %s", vt.ID)
return vt, nil
}
// CreatePrivateVolumeType will create a private volume type with a random
// name and no extra specs. An error will be returned if the volume type was
// unable to be created.
func CreatePrivateVolumeType(t *testing.T, client *gophercloud.ServiceClient) (*volumetypes.VolumeType, error) {
name := tools.RandomString("ACPTTEST", 16)
description := "create_from_gophercloud"
isPublic := false
t.Logf("Attempting to create volume type: %s", name)
createOpts := volumetypes.CreateOpts{
Name: name,
ExtraSpecs: map[string]string{},
Description: description,
IsPublic: &isPublic,
}
vt, err := volumetypes.Create(client, createOpts).Extract()
if err != nil {
return nil, err
}
tools.PrintResource(t, vt)
th.AssertEquals(t, vt.IsPublic, false)
th.AssertEquals(t, vt.Name, name)
th.AssertEquals(t, vt.Description, description)
t.Logf("Successfully created volume type: %s", vt.ID)
return vt, nil
}
// DeleteSnapshot will delete a snapshot. A fatal error will occur if the
// snapshot failed to be deleted.
func DeleteSnapshot(t *testing.T, client *gophercloud.ServiceClient, snapshot *snapshots.Snapshot) {
err := snapshots.Delete(client, snapshot.ID).ExtractErr()
if err != nil {
t.Fatalf("Unable to delete snapshot %s: %+v", snapshot.ID, err)
}
// Volumes can't be deleted until their snapshots have been,
// so block until the snapshoth as been deleted.
err = tools.WaitFor(func() (bool, error) {
_, err := snapshots.Get(client, snapshot.ID).Extract()
if err != nil {
return true, nil
}
return false, nil
})
if err != nil {
t.Fatalf("Error waiting for snapshot to delete: %v", err)
}
t.Logf("Deleted snapshot: %s", snapshot.ID)
}
// DeleteVolume will delete a volume. A fatal error will occur if the volume
// failed to be deleted. This works best when used as a deferred function.
func DeleteVolume(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) {
t.Logf("Attempting to delete volume: %s", volume.ID)
err := volumes.Delete(client, volume.ID, volumes.DeleteOpts{}).ExtractErr()
if err != nil {
t.Fatalf("Unable to delete volume %s: %v", volume.ID, err)
}
// VolumeTypes can't be deleted until their volumes have been,
// so block until the volume is deleted.
err = tools.WaitFor(func() (bool, error) {
_, err := volumes.Get(client, volume.ID).Extract()
if err != nil {
return true, nil
}
return false, nil
})
if err != nil {
t.Fatalf("Error waiting for volume to delete: %v", err)
}
t.Logf("Successfully deleted volume: %s", volume.ID)
}
// DeleteVolumeType will delete a volume type. A fatal error will occur if the
// volume type failed to be deleted. This works best when used as a deferred
// function.
func DeleteVolumeType(t *testing.T, client *gophercloud.ServiceClient, vt *volumetypes.VolumeType) {
t.Logf("Attempting to delete volume type: %s", vt.ID)
err := volumetypes.Delete(client, vt.ID).ExtractErr()
if err != nil {
t.Fatalf("Unable to delete volume %s: %v", vt.ID, err)
}
t.Logf("Successfully deleted volume type: %s", vt.ID)
}
// CreateQoS will create a QoS with one spec and a random name. An
// error will be returned if the volume was unable to be created.
func CreateQoS(t *testing.T, client *gophercloud.ServiceClient) (*qos.QoS, error) {
name := tools.RandomString("ACPTTEST", 16)
t.Logf("Attempting to create QoS: %s", name)
createOpts := qos.CreateOpts{
Name: name,
Consumer: qos.ConsumerFront,
Specs: map[string]string{
"read_iops_sec": "20000",
},
}
qs, err := qos.Create(client, createOpts).Extract()
if err != nil {
return nil, err
}
tools.PrintResource(t, qs)
th.AssertEquals(t, qs.Consumer, "front-end")
th.AssertEquals(t, qs.Name, name)
th.AssertDeepEquals(t, qs.Specs, createOpts.Specs)
t.Logf("Successfully created QoS: %s", qs.ID)
return qs, nil
}
// DeleteQoS will delete a QoS. A fatal error will occur if the QoS
// failed to be deleted. This works best when used as a deferred function.
func DeleteQoS(t *testing.T, client *gophercloud.ServiceClient, qs *qos.QoS) {
t.Logf("Attempting to delete QoS: %s", qs.ID)
deleteOpts := qos.DeleteOpts{
Force: true,
}
err := qos.Delete(client, qs.ID, deleteOpts).ExtractErr()
if err != nil {
t.Fatalf("Unable to delete QoS %s: %v", qs.ID, err)
}
t.Logf("Successfully deleted QoS: %s", qs.ID)
}
|
