ruby-libvirt-catphish 0.7.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/COPYING +510 -0
- data/NEWS +141 -0
- data/README +219 -0
- data/README.rdoc +28 -0
- data/Rakefile +166 -0
- data/ext/libvirt/_libvirt.c +1033 -0
- data/ext/libvirt/common.c +490 -0
- data/ext/libvirt/common.h +285 -0
- data/ext/libvirt/connect.c +3501 -0
- data/ext/libvirt/connect.h +12 -0
- data/ext/libvirt/domain.c +5907 -0
- data/ext/libvirt/domain.h +11 -0
- data/ext/libvirt/extconf.h +392 -0
- data/ext/libvirt/extconf.rb +506 -0
- data/ext/libvirt/interface.c +200 -0
- data/ext/libvirt/interface.h +8 -0
- data/ext/libvirt/network.c +555 -0
- data/ext/libvirt/network.h +8 -0
- data/ext/libvirt/nodedevice.c +299 -0
- data/ext/libvirt/nodedevice.h +8 -0
- data/ext/libvirt/nwfilter.c +138 -0
- data/ext/libvirt/nwfilter.h +8 -0
- data/ext/libvirt/secret.c +268 -0
- data/ext/libvirt/secret.h +8 -0
- data/ext/libvirt/storage.c +1022 -0
- data/ext/libvirt/storage.h +6 -0
- data/ext/libvirt/stream.c +392 -0
- data/ext/libvirt/stream.h +9 -0
- data/lib/libvirt.rb +40 -0
- data/tests/test_conn.rb +818 -0
- data/tests/test_domain.rb +1443 -0
- data/tests/test_interface.rb +100 -0
- data/tests/test_network.rb +175 -0
- data/tests/test_nodedevice.rb +90 -0
- data/tests/test_nwfilter.rb +60 -0
- data/tests/test_open.rb +250 -0
- data/tests/test_secret.rb +114 -0
- data/tests/test_storage.rb +527 -0
- data/tests/test_stream.rb +171 -0
- data/tests/test_utils.rb +254 -0
- metadata +84 -0
@@ -0,0 +1,268 @@
|
|
1
|
+
/*
|
2
|
+
* secret.c: virSecret methods
|
3
|
+
*
|
4
|
+
* Copyright (C) 2010 Red Hat Inc.
|
5
|
+
* Copyright (C) 2013-2016 Chris Lalancette <clalancette@gmail.com>
|
6
|
+
*
|
7
|
+
* This library is free software; you can redistribute it and/or
|
8
|
+
* modify it under the terms of the GNU Lesser General Public
|
9
|
+
* License as published by the Free Software Foundation; either
|
10
|
+
* version 2.1 of the License, or (at your option) any later version.
|
11
|
+
*
|
12
|
+
* This library is distributed in the hope that it will be useful,
|
13
|
+
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
14
|
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
15
|
+
* Lesser General Public License for more details.
|
16
|
+
*
|
17
|
+
* You should have received a copy of the GNU Lesser General Public
|
18
|
+
* License along with this library; if not, write to the Free Software
|
19
|
+
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
20
|
+
*/
|
21
|
+
|
22
|
+
#include <ruby.h>
|
23
|
+
#include <libvirt/libvirt.h>
|
24
|
+
#include <libvirt/virterror.h>
|
25
|
+
#include "common.h"
|
26
|
+
#include "connect.h"
|
27
|
+
#include "extconf.h"
|
28
|
+
|
29
|
+
#if HAVE_TYPE_VIRSECRETPTR
|
30
|
+
static VALUE c_secret;
|
31
|
+
|
32
|
+
static void secret_free(void *s)
|
33
|
+
{
|
34
|
+
ruby_libvirt_free_struct(Secret, s);
|
35
|
+
}
|
36
|
+
|
37
|
+
static virSecretPtr secret_get(VALUE s)
|
38
|
+
{
|
39
|
+
ruby_libvirt_get_struct(Secret, s);
|
40
|
+
}
|
41
|
+
|
42
|
+
VALUE ruby_libvirt_secret_new(virSecretPtr s, VALUE conn)
|
43
|
+
{
|
44
|
+
return ruby_libvirt_new_class(c_secret, s, conn, secret_free);
|
45
|
+
}
|
46
|
+
|
47
|
+
/*
|
48
|
+
* call-seq:
|
49
|
+
* secret.uuid -> String
|
50
|
+
*
|
51
|
+
* Call virSecretGetUUIDString[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretGetUUIDString]
|
52
|
+
* to retrieve the UUID for this secret.
|
53
|
+
*/
|
54
|
+
static VALUE libvirt_secret_uuid(VALUE s)
|
55
|
+
{
|
56
|
+
ruby_libvirt_generate_uuid(virSecretGetUUIDString,
|
57
|
+
ruby_libvirt_connect_get(s), secret_get(s));
|
58
|
+
}
|
59
|
+
|
60
|
+
/*
|
61
|
+
* call-seq:
|
62
|
+
* secret.usagetype -> Fixnum
|
63
|
+
*
|
64
|
+
* Call virSecretGetUsageType[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretGetUsageType]
|
65
|
+
* to retrieve the usagetype for this secret.
|
66
|
+
*/
|
67
|
+
static VALUE libvirt_secret_usagetype(VALUE s)
|
68
|
+
{
|
69
|
+
ruby_libvirt_generate_call_int(virSecretGetUsageType,
|
70
|
+
ruby_libvirt_connect_get(s),
|
71
|
+
secret_get(s));
|
72
|
+
}
|
73
|
+
|
74
|
+
/*
|
75
|
+
* call-seq:
|
76
|
+
* secret.usageid -> String
|
77
|
+
*
|
78
|
+
* Call virSecretGetUsageID[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretGetUsageID]
|
79
|
+
* to retrieve the usageid for this secret.
|
80
|
+
*/
|
81
|
+
static VALUE libvirt_secret_usageid(VALUE s)
|
82
|
+
{
|
83
|
+
ruby_libvirt_generate_call_string(virSecretGetUsageID,
|
84
|
+
ruby_libvirt_connect_get(s), 0,
|
85
|
+
secret_get(s));
|
86
|
+
}
|
87
|
+
|
88
|
+
/*
|
89
|
+
* call-seq:
|
90
|
+
* secret.xml_desc(flags=0) -> String
|
91
|
+
*
|
92
|
+
* Call virSecretGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretGetXMLDesc]
|
93
|
+
* to retrieve the XML for this secret.
|
94
|
+
*/
|
95
|
+
static VALUE libvirt_secret_xml_desc(int argc, VALUE *argv, VALUE s)
|
96
|
+
{
|
97
|
+
VALUE flags = RUBY_Qnil;
|
98
|
+
|
99
|
+
rb_scan_args(argc, argv, "01", &flags);
|
100
|
+
|
101
|
+
ruby_libvirt_generate_call_string(virSecretGetXMLDesc,
|
102
|
+
ruby_libvirt_connect_get(s), 1,
|
103
|
+
secret_get(s),
|
104
|
+
ruby_libvirt_value_to_uint(flags));
|
105
|
+
}
|
106
|
+
|
107
|
+
/*
|
108
|
+
* call-seq:
|
109
|
+
* secret.set_value(value, flags=0) -> nil
|
110
|
+
*
|
111
|
+
* Call virSecretSetValue[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretSetValue]
|
112
|
+
* to set a new value in this secret. Deprecated; use secret.value= instead.
|
113
|
+
*/
|
114
|
+
static VALUE libvirt_secret_set_value(int argc, VALUE *argv, VALUE s)
|
115
|
+
{
|
116
|
+
VALUE flags = RUBY_Qnil, value;
|
117
|
+
|
118
|
+
rb_scan_args(argc, argv, "11", &value, &flags);
|
119
|
+
|
120
|
+
StringValue(value);
|
121
|
+
|
122
|
+
ruby_libvirt_generate_call_nil(virSecretSetValue,
|
123
|
+
ruby_libvirt_connect_get(s),
|
124
|
+
secret_get(s),
|
125
|
+
(unsigned char *)RSTRING_PTR(value),
|
126
|
+
RSTRING_LEN(value),
|
127
|
+
ruby_libvirt_value_to_uint(flags));
|
128
|
+
}
|
129
|
+
|
130
|
+
/*
|
131
|
+
* call-seq:
|
132
|
+
* secret.value = value,flags=0
|
133
|
+
*
|
134
|
+
* Call virSecretSetValue[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretSetValue]
|
135
|
+
* to set a new value in this secret.
|
136
|
+
*/
|
137
|
+
static VALUE libvirt_secret_value_equal(VALUE s, VALUE in)
|
138
|
+
{
|
139
|
+
VALUE flags, value;
|
140
|
+
|
141
|
+
if (TYPE(in) == T_STRING) {
|
142
|
+
value = in;
|
143
|
+
flags = INT2NUM(0);
|
144
|
+
}
|
145
|
+
else if (TYPE(in) == T_ARRAY) {
|
146
|
+
if (RARRAY_LEN(in) != 2) {
|
147
|
+
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
|
148
|
+
RARRAY_LEN(in));
|
149
|
+
}
|
150
|
+
value = rb_ary_entry(in, 0);
|
151
|
+
flags = rb_ary_entry(in, 1);
|
152
|
+
}
|
153
|
+
else {
|
154
|
+
rb_raise(rb_eTypeError,
|
155
|
+
"wrong argument type (expected Number or Array)");
|
156
|
+
}
|
157
|
+
|
158
|
+
StringValue(value);
|
159
|
+
|
160
|
+
ruby_libvirt_generate_call_nil(virSecretSetValue,
|
161
|
+
ruby_libvirt_connect_get(s),
|
162
|
+
secret_get(s),
|
163
|
+
(unsigned char *)RSTRING_PTR(value),
|
164
|
+
RSTRING_LEN(value), NUM2UINT(flags));
|
165
|
+
}
|
166
|
+
|
167
|
+
/*
|
168
|
+
* call-seq:
|
169
|
+
* secret.value(flags=0) -> String
|
170
|
+
*
|
171
|
+
* Call virSecretGetValue[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretGetValue]
|
172
|
+
* to retrieve the value from this secret.
|
173
|
+
*/
|
174
|
+
static VALUE libvirt_secret_value(int argc, VALUE *argv, VALUE s)
|
175
|
+
{
|
176
|
+
VALUE flags = RUBY_Qnil, ret;
|
177
|
+
unsigned char *val;
|
178
|
+
size_t value_size;
|
179
|
+
int exception = 0;
|
180
|
+
struct ruby_libvirt_str_new_arg args;
|
181
|
+
|
182
|
+
rb_scan_args(argc, argv, "01", &flags);
|
183
|
+
|
184
|
+
val = virSecretGetValue(secret_get(s), &value_size,
|
185
|
+
ruby_libvirt_value_to_uint(flags));
|
186
|
+
|
187
|
+
ruby_libvirt_raise_error_if(val == NULL, e_RetrieveError,
|
188
|
+
"virSecretGetValue",
|
189
|
+
ruby_libvirt_connect_get(s));
|
190
|
+
|
191
|
+
args.val = (char *)val;
|
192
|
+
args.size = value_size;
|
193
|
+
ret = rb_protect(ruby_libvirt_str_new_wrap, (VALUE)&args, &exception);
|
194
|
+
free(val);
|
195
|
+
if (exception) {
|
196
|
+
rb_jump_tag(exception);
|
197
|
+
}
|
198
|
+
|
199
|
+
return ret;
|
200
|
+
}
|
201
|
+
|
202
|
+
/*
|
203
|
+
* call-seq:
|
204
|
+
* secret.undefine -> nil
|
205
|
+
*
|
206
|
+
* Call virSecretUndefine[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretUndefine]
|
207
|
+
* to undefine this secret.
|
208
|
+
*/
|
209
|
+
static VALUE libvirt_secret_undefine(VALUE s)
|
210
|
+
{
|
211
|
+
ruby_libvirt_generate_call_nil(virSecretUndefine,
|
212
|
+
ruby_libvirt_connect_get(s),
|
213
|
+
secret_get(s));
|
214
|
+
}
|
215
|
+
|
216
|
+
/*
|
217
|
+
* call-seq:
|
218
|
+
* secret.free -> nil
|
219
|
+
*
|
220
|
+
* Call virSecretFree[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretFree]
|
221
|
+
* to free this secret. After this call the secret object is no longer valid.
|
222
|
+
*/
|
223
|
+
static VALUE libvirt_secret_free(VALUE s)
|
224
|
+
{
|
225
|
+
ruby_libvirt_generate_call_free(Secret, s);
|
226
|
+
}
|
227
|
+
|
228
|
+
#endif
|
229
|
+
|
230
|
+
/*
|
231
|
+
* Class Libvirt::Secret
|
232
|
+
*/
|
233
|
+
void ruby_libvirt_secret_init(void)
|
234
|
+
{
|
235
|
+
#if HAVE_TYPE_VIRSECRETPTR
|
236
|
+
c_secret = rb_define_class_under(m_libvirt, "Secret", rb_cObject);
|
237
|
+
|
238
|
+
rb_define_attr(c_secret, "connection", 1, 0);
|
239
|
+
|
240
|
+
rb_define_const(c_secret, "USAGE_TYPE_VOLUME",
|
241
|
+
INT2NUM(VIR_SECRET_USAGE_TYPE_VOLUME));
|
242
|
+
|
243
|
+
#if HAVE_CONST_VIR_SECRET_USAGE_TYPE_CEPH
|
244
|
+
rb_define_const(c_secret, "USAGE_TYPE_CEPH",
|
245
|
+
INT2NUM(VIR_SECRET_USAGE_TYPE_CEPH));
|
246
|
+
#endif
|
247
|
+
#if HAVE_CONST_VIR_SECRET_USAGE_TYPE_ISCSI
|
248
|
+
rb_define_const(c_secret, "USAGE_TYPE_ISCSI",
|
249
|
+
INT2NUM(VIR_SECRET_USAGE_TYPE_ISCSI));
|
250
|
+
#endif
|
251
|
+
#if HAVE_CONST_VIR_SECRET_USAGE_TYPE_NONE
|
252
|
+
rb_define_const(c_secret, "USAGE_TYPE_NONE",
|
253
|
+
INT2NUM(VIR_SECRET_USAGE_TYPE_NONE));
|
254
|
+
#endif
|
255
|
+
|
256
|
+
/* Secret object methods */
|
257
|
+
rb_define_method(c_secret, "uuid", libvirt_secret_uuid, 0);
|
258
|
+
rb_define_method(c_secret, "usagetype", libvirt_secret_usagetype, 0);
|
259
|
+
rb_define_method(c_secret, "usageid", libvirt_secret_usageid, 0);
|
260
|
+
rb_define_method(c_secret, "xml_desc", libvirt_secret_xml_desc, -1);
|
261
|
+
rb_define_method(c_secret, "set_value", libvirt_secret_set_value, -1);
|
262
|
+
rb_define_method(c_secret, "value=", libvirt_secret_value_equal, 1);
|
263
|
+
rb_define_method(c_secret, "value", libvirt_secret_value, -1);
|
264
|
+
rb_define_alias(c_secret, "get_value", "value");
|
265
|
+
rb_define_method(c_secret, "undefine", libvirt_secret_undefine, 0);
|
266
|
+
rb_define_method(c_secret, "free", libvirt_secret_free, 0);
|
267
|
+
#endif
|
268
|
+
}
|
@@ -0,0 +1,1022 @@
|
|
1
|
+
/*
|
2
|
+
* storage.c: virStoragePool and virStorageVolume methods
|
3
|
+
*
|
4
|
+
* Copyright (C) 2007,2010 Red Hat Inc.
|
5
|
+
* Copyright (C) 2013-2016 Chris Lalancette <clalancette@gmail.com>
|
6
|
+
*
|
7
|
+
* This library is free software; you can redistribute it and/or
|
8
|
+
* modify it under the terms of the GNU Lesser General Public
|
9
|
+
* License as published by the Free Software Foundation; either
|
10
|
+
* version 2.1 of the License, or (at your option) any later version.
|
11
|
+
*
|
12
|
+
* This library is distributed in the hope that it will be useful,
|
13
|
+
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
14
|
+
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
15
|
+
* Lesser General Public License for more details.
|
16
|
+
*
|
17
|
+
* You should have received a copy of the GNU Lesser General Public
|
18
|
+
* License along with this library; if not, write to the Free Software
|
19
|
+
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
20
|
+
*/
|
21
|
+
|
22
|
+
#include <ruby.h>
|
23
|
+
#include <libvirt/libvirt.h>
|
24
|
+
#include <libvirt/virterror.h>
|
25
|
+
#include "common.h"
|
26
|
+
#include "connect.h"
|
27
|
+
#include "extconf.h"
|
28
|
+
#include "stream.h"
|
29
|
+
|
30
|
+
#if HAVE_TYPE_VIRSTORAGEVOLPTR
|
31
|
+
/* this has to be here (as opposed to below with the rest of the volume
|
32
|
+
* stuff) because libvirt_storage_vol_get_pool() relies on it
|
33
|
+
*/
|
34
|
+
static virStorageVolPtr vol_get(VALUE v)
|
35
|
+
{
|
36
|
+
ruby_libvirt_get_struct(StorageVol, v);
|
37
|
+
}
|
38
|
+
#endif
|
39
|
+
|
40
|
+
#if HAVE_TYPE_VIRSTORAGEPOOLPTR
|
41
|
+
static VALUE c_storage_pool;
|
42
|
+
static VALUE c_storage_pool_info;
|
43
|
+
|
44
|
+
/*
|
45
|
+
* Class Libvirt::StoragePool
|
46
|
+
*/
|
47
|
+
|
48
|
+
static void pool_free(void *d)
|
49
|
+
{
|
50
|
+
ruby_libvirt_free_struct(StoragePool, d);
|
51
|
+
}
|
52
|
+
|
53
|
+
static virStoragePoolPtr pool_get(VALUE p)
|
54
|
+
{
|
55
|
+
ruby_libvirt_get_struct(StoragePool, p);
|
56
|
+
}
|
57
|
+
|
58
|
+
VALUE pool_new(virStoragePoolPtr p, VALUE conn)
|
59
|
+
{
|
60
|
+
return ruby_libvirt_new_class(c_storage_pool, p, conn, pool_free);
|
61
|
+
}
|
62
|
+
|
63
|
+
/*
|
64
|
+
* call-seq:
|
65
|
+
* vol.pool -> Libvirt::StoragePool
|
66
|
+
*
|
67
|
+
* Call virStoragePoolLookupByVolume[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolLookupByVolume]
|
68
|
+
* to retrieve the storage pool for this volume.
|
69
|
+
*/
|
70
|
+
static VALUE libvirt_storage_vol_pool(VALUE v)
|
71
|
+
{
|
72
|
+
virStoragePoolPtr pool;
|
73
|
+
|
74
|
+
pool = virStoragePoolLookupByVolume(vol_get(v));
|
75
|
+
ruby_libvirt_raise_error_if(pool == NULL, e_RetrieveError,
|
76
|
+
"virStoragePoolLookupByVolume",
|
77
|
+
ruby_libvirt_connect_get(v));
|
78
|
+
|
79
|
+
return pool_new(pool, ruby_libvirt_conn_attr(v));
|
80
|
+
}
|
81
|
+
|
82
|
+
/*
|
83
|
+
* call-seq:
|
84
|
+
* pool.build(flags=0) -> nil
|
85
|
+
*
|
86
|
+
* Call virStoragePoolBuild[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolBuild]
|
87
|
+
* to build this storage pool.
|
88
|
+
*/
|
89
|
+
static VALUE libvirt_storage_pool_build(int argc, VALUE *argv, VALUE p)
|
90
|
+
{
|
91
|
+
VALUE flags = RUBY_Qnil;
|
92
|
+
|
93
|
+
rb_scan_args(argc, argv, "01", &flags);
|
94
|
+
|
95
|
+
ruby_libvirt_generate_call_nil(virStoragePoolBuild,
|
96
|
+
ruby_libvirt_connect_get(p),
|
97
|
+
pool_get(p),
|
98
|
+
ruby_libvirt_value_to_uint(flags));
|
99
|
+
}
|
100
|
+
|
101
|
+
/*
|
102
|
+
* call-seq:
|
103
|
+
* pool.undefine -> nil
|
104
|
+
*
|
105
|
+
* Call virStoragePoolUndefine[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolUndefine]
|
106
|
+
* to undefine this storage pool.
|
107
|
+
*/
|
108
|
+
static VALUE libvirt_storage_pool_undefine(VALUE p)
|
109
|
+
{
|
110
|
+
ruby_libvirt_generate_call_nil(virStoragePoolUndefine,
|
111
|
+
ruby_libvirt_connect_get(p),
|
112
|
+
pool_get(p));
|
113
|
+
}
|
114
|
+
|
115
|
+
/*
|
116
|
+
* call-seq:
|
117
|
+
* pool.create(flags=0) -> nil
|
118
|
+
*
|
119
|
+
* Call virStoragePoolCreate[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolCreate]
|
120
|
+
* to start this storage pool.
|
121
|
+
*/
|
122
|
+
static VALUE libvirt_storage_pool_create(int argc, VALUE *argv, VALUE p)
|
123
|
+
{
|
124
|
+
VALUE flags = RUBY_Qnil;
|
125
|
+
|
126
|
+
rb_scan_args(argc, argv, "01", &flags);
|
127
|
+
|
128
|
+
ruby_libvirt_generate_call_nil(virStoragePoolCreate,
|
129
|
+
ruby_libvirt_connect_get(p),
|
130
|
+
pool_get(p),
|
131
|
+
ruby_libvirt_value_to_uint(flags));
|
132
|
+
}
|
133
|
+
|
134
|
+
/*
|
135
|
+
* call-seq:
|
136
|
+
* pool.destroy -> nil
|
137
|
+
*
|
138
|
+
* Call virStoragePoolDestroy[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolDestroy]
|
139
|
+
* to shutdown this storage pool.
|
140
|
+
*/
|
141
|
+
static VALUE libvirt_storage_pool_destroy(VALUE p)
|
142
|
+
{
|
143
|
+
ruby_libvirt_generate_call_nil(virStoragePoolDestroy,
|
144
|
+
ruby_libvirt_connect_get(p),
|
145
|
+
pool_get(p));
|
146
|
+
}
|
147
|
+
|
148
|
+
/*
|
149
|
+
* call-seq:
|
150
|
+
* pool.delete(flags=0) -> nil
|
151
|
+
*
|
152
|
+
* Call virStoragePoolDelete[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolDelete]
|
153
|
+
* to delete the data corresponding to this data pool. This is a destructive
|
154
|
+
* operation.
|
155
|
+
*/
|
156
|
+
static VALUE libvirt_storage_pool_delete(int argc, VALUE *argv, VALUE p)
|
157
|
+
{
|
158
|
+
VALUE flags = RUBY_Qnil;
|
159
|
+
|
160
|
+
rb_scan_args(argc, argv, "01", &flags);
|
161
|
+
|
162
|
+
ruby_libvirt_generate_call_nil(virStoragePoolDelete,
|
163
|
+
ruby_libvirt_connect_get(p),
|
164
|
+
pool_get(p),
|
165
|
+
ruby_libvirt_value_to_uint(flags));
|
166
|
+
}
|
167
|
+
|
168
|
+
/*
|
169
|
+
* call-seq:
|
170
|
+
* pool.refresh(flags=0) -> nil
|
171
|
+
*
|
172
|
+
* Call virStoragePoolRefresh[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolRefresh]
|
173
|
+
* to refresh the list of volumes in this storage pool.
|
174
|
+
*/
|
175
|
+
static VALUE libvirt_storage_pool_refresh(int argc, VALUE *argv, VALUE p)
|
176
|
+
{
|
177
|
+
VALUE flags = RUBY_Qnil;
|
178
|
+
|
179
|
+
rb_scan_args(argc, argv, "01", &flags);
|
180
|
+
|
181
|
+
ruby_libvirt_generate_call_nil(virStoragePoolRefresh,
|
182
|
+
ruby_libvirt_connect_get(p),
|
183
|
+
pool_get(p),
|
184
|
+
ruby_libvirt_value_to_uint(flags));
|
185
|
+
}
|
186
|
+
|
187
|
+
/*
|
188
|
+
* call-seq:
|
189
|
+
* pool.name -> String
|
190
|
+
*
|
191
|
+
* Call virStoragePoolGetName[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolGetName]
|
192
|
+
* to retrieve the name of this storage pool.
|
193
|
+
*/
|
194
|
+
static VALUE libvirt_storage_pool_name(VALUE p)
|
195
|
+
{
|
196
|
+
ruby_libvirt_generate_call_string(virStoragePoolGetName,
|
197
|
+
ruby_libvirt_connect_get(p), 0,
|
198
|
+
pool_get(p));
|
199
|
+
}
|
200
|
+
|
201
|
+
/*
|
202
|
+
* call-seq:
|
203
|
+
* pool.uuid -> String
|
204
|
+
*
|
205
|
+
* Call virStoragePoolGetUUIDString[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolGetUUIDString]
|
206
|
+
* to retrieve the UUID of this storage pool.
|
207
|
+
*/
|
208
|
+
static VALUE libvirt_storage_pool_uuid(VALUE p)
|
209
|
+
{
|
210
|
+
ruby_libvirt_generate_uuid(virStoragePoolGetUUIDString,
|
211
|
+
ruby_libvirt_connect_get(p), pool_get(p));
|
212
|
+
}
|
213
|
+
|
214
|
+
/*
|
215
|
+
* call-seq:
|
216
|
+
* pool.info -> Libvirt::StoragePoolInfo
|
217
|
+
*
|
218
|
+
* Call virStoragePoolGetInfo[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolGetInfo]
|
219
|
+
* to retrieve information about this storage pool.
|
220
|
+
*/
|
221
|
+
static VALUE libvirt_storage_pool_info(VALUE p)
|
222
|
+
{
|
223
|
+
virStoragePoolInfo info;
|
224
|
+
int r;
|
225
|
+
VALUE result;
|
226
|
+
|
227
|
+
r = virStoragePoolGetInfo(pool_get(p), &info);
|
228
|
+
ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
|
229
|
+
"virStoragePoolGetInfo",
|
230
|
+
ruby_libvirt_connect_get(p));
|
231
|
+
|
232
|
+
result = rb_class_new_instance(0, NULL, c_storage_pool_info);
|
233
|
+
rb_iv_set(result, "@state", INT2NUM(info.state));
|
234
|
+
rb_iv_set(result, "@capacity", ULL2NUM(info.capacity));
|
235
|
+
rb_iv_set(result, "@allocation", ULL2NUM(info.allocation));
|
236
|
+
rb_iv_set(result, "@available", ULL2NUM(info.available));
|
237
|
+
|
238
|
+
return result;
|
239
|
+
}
|
240
|
+
|
241
|
+
/*
|
242
|
+
* call-seq:
|
243
|
+
* pool.xml_desc(flags=0) -> String
|
244
|
+
*
|
245
|
+
* Call virStoragePoolGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolGetXMLDesc]
|
246
|
+
* to retrieve the XML for this storage pool.
|
247
|
+
*/
|
248
|
+
static VALUE libvirt_storage_pool_xml_desc(int argc, VALUE *argv, VALUE p)
|
249
|
+
{
|
250
|
+
VALUE flags = RUBY_Qnil;
|
251
|
+
|
252
|
+
rb_scan_args(argc, argv, "01", &flags);
|
253
|
+
|
254
|
+
ruby_libvirt_generate_call_string(virStoragePoolGetXMLDesc,
|
255
|
+
ruby_libvirt_connect_get(p),
|
256
|
+
1, pool_get(p),
|
257
|
+
ruby_libvirt_value_to_uint(flags));
|
258
|
+
}
|
259
|
+
|
260
|
+
/*
|
261
|
+
* call-seq:
|
262
|
+
* pool.autostart? -> [true|false]
|
263
|
+
*
|
264
|
+
* Call virStoragePoolGetAutostart[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolGetAutostart]
|
265
|
+
* to determine whether this storage pool will autostart when libvirtd starts.
|
266
|
+
*/
|
267
|
+
static VALUE libvirt_storage_pool_autostart(VALUE p)
|
268
|
+
{
|
269
|
+
int r, autostart;
|
270
|
+
|
271
|
+
r = virStoragePoolGetAutostart(pool_get(p), &autostart);
|
272
|
+
ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
|
273
|
+
"virStoragePoolGetAutostart",
|
274
|
+
ruby_libvirt_connect_get(p));
|
275
|
+
|
276
|
+
return autostart ? Qtrue : Qfalse;
|
277
|
+
}
|
278
|
+
|
279
|
+
/*
|
280
|
+
* call-seq:
|
281
|
+
* pool.autostart = [true|false]
|
282
|
+
*
|
283
|
+
* Call virStoragePoolSetAutostart[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolSetAutostart]
|
284
|
+
* to make this storage pool start when libvirtd starts.
|
285
|
+
*/
|
286
|
+
static VALUE libvirt_storage_pool_autostart_equal(VALUE p, VALUE autostart)
|
287
|
+
{
|
288
|
+
if (autostart != Qtrue && autostart != Qfalse) {
|
289
|
+
rb_raise(rb_eTypeError,
|
290
|
+
"wrong argument type (expected TrueClass or FalseClass)");
|
291
|
+
}
|
292
|
+
|
293
|
+
ruby_libvirt_generate_call_nil(virStoragePoolSetAutostart,
|
294
|
+
ruby_libvirt_connect_get(p),
|
295
|
+
pool_get(p), RTEST(autostart) ? 1 : 0);
|
296
|
+
}
|
297
|
+
|
298
|
+
/*
|
299
|
+
* call-seq:
|
300
|
+
* pool.num_of_volumes -> Fixnum
|
301
|
+
*
|
302
|
+
* Call virStoragePoolNumOfVolumes[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolNumOfVolumes]
|
303
|
+
* to retrieve the number of volumes in this storage pool.
|
304
|
+
*/
|
305
|
+
static VALUE libvirt_storage_pool_num_of_volumes(VALUE p)
|
306
|
+
{
|
307
|
+
int n;
|
308
|
+
|
309
|
+
n = virStoragePoolNumOfVolumes(pool_get(p));
|
310
|
+
ruby_libvirt_raise_error_if(n < 0, e_RetrieveError,
|
311
|
+
"virStoragePoolNumOfVolumes",
|
312
|
+
ruby_libvirt_connect_get(p));
|
313
|
+
|
314
|
+
return INT2NUM(n);
|
315
|
+
}
|
316
|
+
|
317
|
+
/*
|
318
|
+
* call-seq:
|
319
|
+
* pool.list_volumes -> list
|
320
|
+
*
|
321
|
+
* Call virStoragePoolListVolumes[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolListVolumes]
|
322
|
+
* to retrieve a list of volume names in this storage pools.
|
323
|
+
*/
|
324
|
+
static VALUE libvirt_storage_pool_list_volumes(VALUE p)
|
325
|
+
{
|
326
|
+
int r, num;
|
327
|
+
char **names;
|
328
|
+
|
329
|
+
num = virStoragePoolNumOfVolumes(pool_get(p));
|
330
|
+
ruby_libvirt_raise_error_if(num < 0, e_RetrieveError,
|
331
|
+
"virStoragePoolNumOfVolumes",
|
332
|
+
ruby_libvirt_connect_get(p));
|
333
|
+
if (num == 0) {
|
334
|
+
return rb_ary_new2(num);
|
335
|
+
}
|
336
|
+
|
337
|
+
names = alloca(sizeof(char *) * num);
|
338
|
+
r = virStoragePoolListVolumes(pool_get(p), names, num);
|
339
|
+
ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
|
340
|
+
"virStoragePoolListVolumes",
|
341
|
+
ruby_libvirt_connect_get(p));
|
342
|
+
|
343
|
+
return ruby_libvirt_generate_list(r, names);
|
344
|
+
}
|
345
|
+
|
346
|
+
/*
|
347
|
+
* call-seq:
|
348
|
+
* pool.free -> nil
|
349
|
+
*
|
350
|
+
* Call virStoragePoolFree[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolFree]
|
351
|
+
* to free this storage pool object. After this call the storage pool object
|
352
|
+
* is no longer valid.
|
353
|
+
*/
|
354
|
+
static VALUE libvirt_storage_pool_free(VALUE p)
|
355
|
+
{
|
356
|
+
ruby_libvirt_generate_call_free(StoragePool, p);
|
357
|
+
}
|
358
|
+
#endif
|
359
|
+
|
360
|
+
#if HAVE_TYPE_VIRSTORAGEVOLPTR
|
361
|
+
/*
|
362
|
+
* Libvirt::StorageVol
|
363
|
+
*/
|
364
|
+
static VALUE c_storage_vol;
|
365
|
+
static VALUE c_storage_vol_info;
|
366
|
+
|
367
|
+
static void vol_free(void *d)
|
368
|
+
{
|
369
|
+
ruby_libvirt_free_struct(StorageVol, d);
|
370
|
+
}
|
371
|
+
|
372
|
+
static VALUE vol_new(virStorageVolPtr v, VALUE conn)
|
373
|
+
{
|
374
|
+
return ruby_libvirt_new_class(c_storage_vol, v, conn, vol_free);
|
375
|
+
}
|
376
|
+
|
377
|
+
/*
|
378
|
+
* call-seq:
|
379
|
+
* pool.lookup_volume_by_name(name) -> Libvirt::StorageVol
|
380
|
+
*
|
381
|
+
* Call virStorageVolLookupByName[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolLookupByName]
|
382
|
+
* to retrieve a storage volume object by name.
|
383
|
+
*/
|
384
|
+
static VALUE libvirt_storage_pool_lookup_vol_by_name(VALUE p, VALUE name)
|
385
|
+
{
|
386
|
+
virStorageVolPtr vol;
|
387
|
+
|
388
|
+
vol = virStorageVolLookupByName(pool_get(p), StringValueCStr(name));
|
389
|
+
ruby_libvirt_raise_error_if(vol == NULL, e_RetrieveError,
|
390
|
+
"virStorageVolLookupByName",
|
391
|
+
ruby_libvirt_connect_get(p));
|
392
|
+
|
393
|
+
return vol_new(vol, ruby_libvirt_conn_attr(p));
|
394
|
+
}
|
395
|
+
|
396
|
+
/*
|
397
|
+
* call-seq:
|
398
|
+
* pool.lookup_volume_by_key(key) -> Libvirt::StorageVol
|
399
|
+
*
|
400
|
+
* Call virStorageVolLookupByKey[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolLookupByKey]
|
401
|
+
* to retrieve a storage volume object by key.
|
402
|
+
*/
|
403
|
+
static VALUE libvirt_storage_pool_lookup_vol_by_key(VALUE p, VALUE key)
|
404
|
+
{
|
405
|
+
virStorageVolPtr vol;
|
406
|
+
|
407
|
+
/* FIXME: Why does this take a connection, not a pool? */
|
408
|
+
vol = virStorageVolLookupByKey(ruby_libvirt_connect_get(p),
|
409
|
+
StringValueCStr(key));
|
410
|
+
ruby_libvirt_raise_error_if(vol == NULL, e_RetrieveError,
|
411
|
+
"virStorageVolLookupByKey",
|
412
|
+
ruby_libvirt_connect_get(p));
|
413
|
+
|
414
|
+
return vol_new(vol, ruby_libvirt_conn_attr(p));
|
415
|
+
}
|
416
|
+
|
417
|
+
/*
|
418
|
+
* call-seq:
|
419
|
+
* pool.lookup_volume_by_path(path) -> Libvirt::StorageVol
|
420
|
+
*
|
421
|
+
* Call virStorageVolLookupByPath[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolLookupByPath]
|
422
|
+
* to retrieve a storage volume object by path.
|
423
|
+
*/
|
424
|
+
static VALUE libvirt_storage_pool_lookup_vol_by_path(VALUE p, VALUE path)
|
425
|
+
{
|
426
|
+
virStorageVolPtr vol;
|
427
|
+
|
428
|
+
/* FIXME: Why does this take a connection, not a pool? */
|
429
|
+
vol = virStorageVolLookupByPath(ruby_libvirt_connect_get(p),
|
430
|
+
StringValueCStr(path));
|
431
|
+
ruby_libvirt_raise_error_if(vol == NULL, e_RetrieveError,
|
432
|
+
"virStorageVolLookupByPath",
|
433
|
+
ruby_libvirt_connect_get(p));
|
434
|
+
|
435
|
+
return vol_new(vol, ruby_libvirt_conn_attr(p));
|
436
|
+
}
|
437
|
+
|
438
|
+
#if HAVE_VIRSTORAGEPOOLLISTALLVOLUMES
|
439
|
+
/*
|
440
|
+
* call-seq:
|
441
|
+
* pool.list_all_volumes(flags=0) -> Array
|
442
|
+
*
|
443
|
+
* Call virStoragePoolListAllVolumes[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolListAllVolumes]
|
444
|
+
* to get an array of volume objects for all volumes.
|
445
|
+
*/
|
446
|
+
static VALUE libvirt_storage_pool_list_all_volumes(int argc, VALUE *argv,
|
447
|
+
VALUE p)
|
448
|
+
{
|
449
|
+
ruby_libvirt_generate_call_list_all(virStorageVolPtr, argc, argv,
|
450
|
+
virStoragePoolListAllVolumes,
|
451
|
+
pool_get(p), p, vol_new,
|
452
|
+
virStorageVolFree);
|
453
|
+
}
|
454
|
+
#endif
|
455
|
+
|
456
|
+
/*
|
457
|
+
* call-seq:
|
458
|
+
* vol.name -> String
|
459
|
+
*
|
460
|
+
* Call virStorageVolGetName[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolGetName]
|
461
|
+
* to retrieve the name of this storage volume.
|
462
|
+
*/
|
463
|
+
static VALUE libvirt_storage_vol_name(VALUE v)
|
464
|
+
{
|
465
|
+
ruby_libvirt_generate_call_string(virStorageVolGetName,
|
466
|
+
ruby_libvirt_connect_get(v), 0,
|
467
|
+
vol_get(v));
|
468
|
+
}
|
469
|
+
|
470
|
+
/*
|
471
|
+
* call-seq:
|
472
|
+
* vol.key -> String
|
473
|
+
*
|
474
|
+
* Call virStorageVolGetKey[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolGetKey]
|
475
|
+
* to retrieve the key for this storage volume.
|
476
|
+
*/
|
477
|
+
static VALUE libvirt_storage_vol_key(VALUE v)
|
478
|
+
{
|
479
|
+
ruby_libvirt_generate_call_string(virStorageVolGetKey,
|
480
|
+
ruby_libvirt_connect_get(v), 0,
|
481
|
+
vol_get(v));
|
482
|
+
}
|
483
|
+
|
484
|
+
/*
|
485
|
+
* call-seq:
|
486
|
+
* pool.create_volume_xml(xml, flags=0) -> Libvirt::StorageVol
|
487
|
+
*
|
488
|
+
* Call virStorageVolCreateXML[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolCreateXML]
|
489
|
+
* to create a new storage volume from xml.
|
490
|
+
*/
|
491
|
+
static VALUE libvirt_storage_pool_create_volume_xml(int argc, VALUE *argv,
|
492
|
+
VALUE p)
|
493
|
+
{
|
494
|
+
virStorageVolPtr vol;
|
495
|
+
VALUE xml, flags = RUBY_Qnil;
|
496
|
+
|
497
|
+
rb_scan_args(argc, argv, "11", &xml, &flags);
|
498
|
+
|
499
|
+
vol = virStorageVolCreateXML(pool_get(p), StringValueCStr(xml),
|
500
|
+
ruby_libvirt_value_to_uint(flags));
|
501
|
+
ruby_libvirt_raise_error_if(vol == NULL, e_Error, "virStorageVolCreateXML",
|
502
|
+
ruby_libvirt_connect_get(p));
|
503
|
+
|
504
|
+
return vol_new(vol, ruby_libvirt_conn_attr(p));
|
505
|
+
}
|
506
|
+
|
507
|
+
#if HAVE_VIRSTORAGEVOLCREATEXMLFROM
|
508
|
+
/*
|
509
|
+
* call-seq:
|
510
|
+
* pool.create_volume_xml_from(xml, clonevol, flags=0) -> Libvirt::StorageVol
|
511
|
+
*
|
512
|
+
* Call virStorageVolCreateXMLFrom[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolCreateXMLFrom]
|
513
|
+
* to clone a volume from an existing volume with the properties specified in
|
514
|
+
* xml.
|
515
|
+
*/
|
516
|
+
static VALUE libvirt_storage_pool_create_volume_xml_from(int argc, VALUE *argv,
|
517
|
+
VALUE p)
|
518
|
+
{
|
519
|
+
virStorageVolPtr vol;
|
520
|
+
VALUE xml, flags = RUBY_Qnil, cloneval = RUBY_Qnil;
|
521
|
+
|
522
|
+
rb_scan_args(argc, argv, "21", &xml, &cloneval, &flags);
|
523
|
+
|
524
|
+
vol = virStorageVolCreateXMLFrom(pool_get(p), StringValueCStr(xml),
|
525
|
+
vol_get(cloneval),
|
526
|
+
ruby_libvirt_value_to_uint(flags));
|
527
|
+
ruby_libvirt_raise_error_if(vol == NULL, e_Error,
|
528
|
+
"virStorageVolCreateXMLFrom",
|
529
|
+
ruby_libvirt_connect_get(p));
|
530
|
+
|
531
|
+
return vol_new(vol, ruby_libvirt_conn_attr(p));
|
532
|
+
}
|
533
|
+
#endif
|
534
|
+
|
535
|
+
#if HAVE_VIRSTORAGEPOOLISACTIVE
|
536
|
+
/*
|
537
|
+
* call-seq:
|
538
|
+
* pool.active? -> [true|false]
|
539
|
+
*
|
540
|
+
* Call virStoragePoolIsActive[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolIsActive]
|
541
|
+
* to determine if this storage pool is active.
|
542
|
+
*/
|
543
|
+
static VALUE libvirt_storage_pool_active_p(VALUE p)
|
544
|
+
{
|
545
|
+
ruby_libvirt_generate_call_truefalse(virStoragePoolIsActive,
|
546
|
+
ruby_libvirt_connect_get(p),
|
547
|
+
pool_get(p));
|
548
|
+
}
|
549
|
+
#endif
|
550
|
+
|
551
|
+
#if HAVE_VIRSTORAGEPOOLISPERSISTENT
|
552
|
+
/*
|
553
|
+
* call-seq:
|
554
|
+
* pool.persistent? -> [true|false]
|
555
|
+
*
|
556
|
+
* Call virStoragePoolIsPersistent[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolIsPersistent]
|
557
|
+
* to determine if this storage pool is persistent.
|
558
|
+
*/
|
559
|
+
static VALUE libvirt_storage_pool_persistent_p(VALUE p)
|
560
|
+
{
|
561
|
+
ruby_libvirt_generate_call_truefalse(virStoragePoolIsPersistent,
|
562
|
+
ruby_libvirt_connect_get(p),
|
563
|
+
pool_get(p));
|
564
|
+
}
|
565
|
+
#endif
|
566
|
+
|
567
|
+
/*
|
568
|
+
* call-seq:
|
569
|
+
* vol.delete(flags=0) -> nil
|
570
|
+
*
|
571
|
+
* Call virStorageVolDelete[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolDelete]
|
572
|
+
* to delete this volume. This is a destructive operation.
|
573
|
+
*/
|
574
|
+
static VALUE libvirt_storage_vol_delete(int argc, VALUE *argv, VALUE v)
|
575
|
+
{
|
576
|
+
VALUE flags = RUBY_Qnil;
|
577
|
+
|
578
|
+
rb_scan_args(argc, argv, "01", &flags);
|
579
|
+
|
580
|
+
ruby_libvirt_generate_call_nil(virStorageVolDelete,
|
581
|
+
ruby_libvirt_connect_get(v),
|
582
|
+
vol_get(v),
|
583
|
+
ruby_libvirt_value_to_uint(flags));
|
584
|
+
}
|
585
|
+
|
586
|
+
#if HAVE_VIRSTORAGEVOLWIPE
|
587
|
+
/*
|
588
|
+
* call-seq:
|
589
|
+
* vol.wipe(flags=0) -> nil
|
590
|
+
*
|
591
|
+
* Call virStorageVolWipe[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolWipe]
|
592
|
+
* to wipe the data from this storage volume. This is a destructive operation.
|
593
|
+
*/
|
594
|
+
static VALUE libvirt_storage_vol_wipe(int argc, VALUE *argv, VALUE v)
|
595
|
+
{
|
596
|
+
VALUE flags = RUBY_Qnil;
|
597
|
+
|
598
|
+
rb_scan_args(argc, argv, "01", &flags);
|
599
|
+
|
600
|
+
ruby_libvirt_generate_call_nil(virStorageVolWipe,
|
601
|
+
ruby_libvirt_connect_get(v),
|
602
|
+
vol_get(v),
|
603
|
+
ruby_libvirt_value_to_uint(flags));
|
604
|
+
}
|
605
|
+
#endif
|
606
|
+
|
607
|
+
/*
|
608
|
+
* call-seq:
|
609
|
+
* vol.info -> Libvirt::StorageVolInfo
|
610
|
+
*
|
611
|
+
* Call virStorageVolGetInfo[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolGetInfo]
|
612
|
+
* to retrieve information about this storage volume.
|
613
|
+
*/
|
614
|
+
static VALUE libvirt_storage_vol_info(VALUE v)
|
615
|
+
{
|
616
|
+
virStorageVolInfo info;
|
617
|
+
int r;
|
618
|
+
VALUE result;
|
619
|
+
|
620
|
+
r = virStorageVolGetInfo(vol_get(v), &info);
|
621
|
+
ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virStorageVolGetInfo",
|
622
|
+
ruby_libvirt_connect_get(v));
|
623
|
+
|
624
|
+
result = rb_class_new_instance(0, NULL, c_storage_vol_info);
|
625
|
+
rb_iv_set(result, "@type", INT2NUM(info.type));
|
626
|
+
rb_iv_set(result, "@capacity", ULL2NUM(info.capacity));
|
627
|
+
rb_iv_set(result, "@allocation", ULL2NUM(info.allocation));
|
628
|
+
|
629
|
+
return result;
|
630
|
+
}
|
631
|
+
|
632
|
+
/*
|
633
|
+
* call-seq:
|
634
|
+
* vol.xml_desc(flags=0) -> String
|
635
|
+
*
|
636
|
+
* Call virStorageVolGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolGetXMLDesc]
|
637
|
+
* to retrieve the xml for this storage volume.
|
638
|
+
*/
|
639
|
+
static VALUE libvirt_storage_vol_xml_desc(int argc, VALUE *argv, VALUE v)
|
640
|
+
{
|
641
|
+
VALUE flags = RUBY_Qnil;
|
642
|
+
|
643
|
+
rb_scan_args(argc, argv, "01", &flags);
|
644
|
+
|
645
|
+
ruby_libvirt_generate_call_string(virStorageVolGetXMLDesc,
|
646
|
+
ruby_libvirt_connect_get(v),
|
647
|
+
1, vol_get(v),
|
648
|
+
ruby_libvirt_value_to_uint(flags));
|
649
|
+
}
|
650
|
+
|
651
|
+
/*
|
652
|
+
* call-seq:
|
653
|
+
* vol.path -> String
|
654
|
+
*
|
655
|
+
* Call virStorageVolGetPath[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolGetPath]
|
656
|
+
* to retrieve the path for this storage volume.
|
657
|
+
*/
|
658
|
+
static VALUE libvirt_storage_vol_path(VALUE v)
|
659
|
+
{
|
660
|
+
ruby_libvirt_generate_call_string(virStorageVolGetPath,
|
661
|
+
ruby_libvirt_connect_get(v), 1,
|
662
|
+
vol_get(v));
|
663
|
+
}
|
664
|
+
|
665
|
+
/*
|
666
|
+
* call-seq:
|
667
|
+
* vol.free -> nil
|
668
|
+
*
|
669
|
+
* Call virStorageVolFree[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolFree]
|
670
|
+
* to free the storage volume object. After this call the storage volume object
|
671
|
+
* is no longer valid.
|
672
|
+
*/
|
673
|
+
static VALUE libvirt_storage_vol_free(VALUE v)
|
674
|
+
{
|
675
|
+
ruby_libvirt_generate_call_free(StorageVol, v);
|
676
|
+
}
|
677
|
+
#endif
|
678
|
+
|
679
|
+
#if HAVE_VIRSTORAGEVOLDOWNLOAD
|
680
|
+
/*
|
681
|
+
* call-seq:
|
682
|
+
* vol.download(stream, offset, length, flags=0) -> nil
|
683
|
+
*
|
684
|
+
* Call virStorageVolDownload[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolDownload]
|
685
|
+
* to download the content of a volume as a stream.
|
686
|
+
*/
|
687
|
+
static VALUE libvirt_storage_vol_download(int argc, VALUE *argv, VALUE v)
|
688
|
+
{
|
689
|
+
VALUE st = RUBY_Qnil, offset = RUBY_Qnil, length = RUBY_Qnil, flags = RUBY_Qnil;
|
690
|
+
|
691
|
+
rb_scan_args(argc, argv, "31", &st, &offset, &length, &flags);
|
692
|
+
|
693
|
+
ruby_libvirt_generate_call_nil(virStorageVolDownload,
|
694
|
+
ruby_libvirt_connect_get(v),
|
695
|
+
vol_get(v), ruby_libvirt_stream_get(st),
|
696
|
+
NUM2ULL(offset), NUM2ULL(length),
|
697
|
+
ruby_libvirt_value_to_uint(flags));
|
698
|
+
}
|
699
|
+
|
700
|
+
/*
|
701
|
+
* call-seq:
|
702
|
+
* vol.upload(stream, offset, length, flags=0) -> nil
|
703
|
+
*
|
704
|
+
* Call virStorageVolUpload[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolUpload]
|
705
|
+
* to upload new content to a volume from a stream.
|
706
|
+
*/
|
707
|
+
static VALUE libvirt_storage_vol_upload(int argc, VALUE *argv, VALUE v)
|
708
|
+
{
|
709
|
+
VALUE st = RUBY_Qnil, offset = RUBY_Qnil, length = RUBY_Qnil, flags = RUBY_Qnil;
|
710
|
+
|
711
|
+
rb_scan_args(argc, argv, "31", &st, &offset, &length, &flags);
|
712
|
+
|
713
|
+
ruby_libvirt_generate_call_nil(virStorageVolUpload,
|
714
|
+
ruby_libvirt_connect_get(v),
|
715
|
+
vol_get(v), ruby_libvirt_stream_get(st),
|
716
|
+
NUM2ULL(offset), NUM2ULL(length),
|
717
|
+
ruby_libvirt_value_to_uint(flags));
|
718
|
+
}
|
719
|
+
#endif
|
720
|
+
|
721
|
+
#if HAVE_VIRSTORAGEVOLWIPEPATTERN
|
722
|
+
/*
|
723
|
+
* call-seq:
|
724
|
+
* vol.wipe_pattern(alg, flags=0) -> nil
|
725
|
+
*
|
726
|
+
* Call virStorageVolWipePattern[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolWipePattern]
|
727
|
+
* to wipe the data from this storage volume. This is a destructive operation.
|
728
|
+
*/
|
729
|
+
static VALUE libvirt_storage_vol_wipe_pattern(int argc, VALUE *argv, VALUE v)
|
730
|
+
{
|
731
|
+
VALUE alg = RUBY_Qnil, flags = RUBY_Qnil;
|
732
|
+
|
733
|
+
rb_scan_args(argc, argv, "11", &alg, &flags);
|
734
|
+
|
735
|
+
ruby_libvirt_generate_call_nil(virStorageVolWipePattern,
|
736
|
+
ruby_libvirt_connect_get(v),
|
737
|
+
vol_get(v), NUM2UINT(alg),
|
738
|
+
ruby_libvirt_value_to_uint(flags));
|
739
|
+
}
|
740
|
+
#endif
|
741
|
+
|
742
|
+
#if HAVE_VIRSTORAGEVOLRESIZE
|
743
|
+
/*
|
744
|
+
* call-seq:
|
745
|
+
* vol.resize(capacity, flags=0) -> nil
|
746
|
+
*
|
747
|
+
* Call virStorageVolResize[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolResize]
|
748
|
+
* to resize the associated storage volume.
|
749
|
+
*/
|
750
|
+
static VALUE libvirt_storage_vol_resize(int argc, VALUE *argv, VALUE v)
|
751
|
+
{
|
752
|
+
VALUE capacity = RUBY_Qnil, flags = RUBY_Qnil;
|
753
|
+
|
754
|
+
rb_scan_args(argc, argv, "11", &capacity, &flags);
|
755
|
+
|
756
|
+
ruby_libvirt_generate_call_nil(virStorageVolResize,
|
757
|
+
ruby_libvirt_connect_get(v),
|
758
|
+
vol_get(v), NUM2ULL(capacity),
|
759
|
+
ruby_libvirt_value_to_uint(flags));
|
760
|
+
}
|
761
|
+
#endif
|
762
|
+
|
763
|
+
void ruby_libvirt_storage_init(void)
|
764
|
+
{
|
765
|
+
/*
|
766
|
+
* Class Libvirt::StoragePool and Libvirt::StoragePoolInfo
|
767
|
+
*/
|
768
|
+
#if HAVE_TYPE_VIRSTORAGEPOOLPTR
|
769
|
+
c_storage_pool_info = rb_define_class_under(m_libvirt, "StoragePoolInfo",
|
770
|
+
rb_cObject);
|
771
|
+
rb_define_attr(c_storage_pool_info, "state", 1, 0);
|
772
|
+
rb_define_attr(c_storage_pool_info, "capacity", 1, 0);
|
773
|
+
rb_define_attr(c_storage_pool_info, "allocation", 1, 0);
|
774
|
+
rb_define_attr(c_storage_pool_info, "available", 1, 0);
|
775
|
+
|
776
|
+
c_storage_pool = rb_define_class_under(m_libvirt, "StoragePool",
|
777
|
+
rb_cObject);
|
778
|
+
|
779
|
+
rb_define_attr(c_storage_pool, "connection", 1, 0);
|
780
|
+
|
781
|
+
/* virStoragePoolState */
|
782
|
+
rb_define_const(c_storage_pool, "INACTIVE",
|
783
|
+
INT2NUM(VIR_STORAGE_POOL_INACTIVE));
|
784
|
+
rb_define_const(c_storage_pool, "BUILDING",
|
785
|
+
INT2NUM(VIR_STORAGE_POOL_BUILDING));
|
786
|
+
rb_define_const(c_storage_pool, "RUNNING",
|
787
|
+
INT2NUM(VIR_STORAGE_POOL_RUNNING));
|
788
|
+
rb_define_const(c_storage_pool, "DEGRADED",
|
789
|
+
INT2NUM(VIR_STORAGE_POOL_DEGRADED));
|
790
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_INACCESSIBLE
|
791
|
+
rb_define_const(c_storage_pool, "INACCESSIBLE",
|
792
|
+
INT2NUM(VIR_STORAGE_POOL_INACCESSIBLE));
|
793
|
+
#endif
|
794
|
+
|
795
|
+
#if HAVE_CONST_VIR_STORAGE_XML_INACTIVE
|
796
|
+
rb_define_const(c_storage_pool, "XML_INACTIVE",
|
797
|
+
INT2NUM(VIR_STORAGE_XML_INACTIVE));
|
798
|
+
#endif
|
799
|
+
|
800
|
+
/* virStoragePoolBuildFlags */
|
801
|
+
rb_define_const(c_storage_pool, "BUILD_NEW",
|
802
|
+
INT2NUM(VIR_STORAGE_POOL_BUILD_NEW));
|
803
|
+
rb_define_const(c_storage_pool, "BUILD_REPAIR",
|
804
|
+
INT2NUM(VIR_STORAGE_POOL_BUILD_REPAIR));
|
805
|
+
rb_define_const(c_storage_pool, "BUILD_RESIZE",
|
806
|
+
INT2NUM(VIR_STORAGE_POOL_BUILD_RESIZE));
|
807
|
+
|
808
|
+
/* virStoragePoolDeleteFlags */
|
809
|
+
rb_define_const(c_storage_pool, "DELETE_NORMAL",
|
810
|
+
INT2NUM(VIR_STORAGE_POOL_DELETE_NORMAL));
|
811
|
+
rb_define_const(c_storage_pool, "DELETE_ZEROED",
|
812
|
+
INT2NUM(VIR_STORAGE_POOL_DELETE_ZEROED));
|
813
|
+
|
814
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA
|
815
|
+
rb_define_const(c_storage_pool, "CREATE_PREALLOC_METADATA",
|
816
|
+
INT2NUM(VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA));
|
817
|
+
#endif
|
818
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_CREATE_REFLINK
|
819
|
+
rb_define_const(c_storage_pool, "CREATE_REFLINK",
|
820
|
+
INT2NUM(VIR_STORAGE_VOL_CREATE_REFLINK));
|
821
|
+
#endif
|
822
|
+
|
823
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_CREATE_NORMAL
|
824
|
+
rb_define_const(c_storage_pool, "CREATE_NORMAL",
|
825
|
+
INT2NUM(VIR_STORAGE_POOL_CREATE_NORMAL));
|
826
|
+
#endif
|
827
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_CREATE_WITH_BUILD
|
828
|
+
rb_define_const(c_storage_pool, "CREATE_WITH_BUILD",
|
829
|
+
INT2NUM(VIR_STORAGE_POOL_CREATE_WITH_BUILD));
|
830
|
+
#endif
|
831
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_CREATE_WITH_BUILD_OVERWRITE
|
832
|
+
rb_define_const(c_storage_pool, "CREATE_WITH_BUILD_OVERWRITE",
|
833
|
+
INT2NUM(VIR_STORAGE_POOL_CREATE_WITH_BUILD_OVERWRITE));
|
834
|
+
#endif
|
835
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_CREATE_WITH_BUILD_NO_OVERWRITE
|
836
|
+
rb_define_const(c_storage_pool, "CREATE_WITH_BUILD_NO_OVERWRITE",
|
837
|
+
INT2NUM(VIR_STORAGE_POOL_CREATE_WITH_BUILD_NO_OVERWRITE));
|
838
|
+
#endif
|
839
|
+
|
840
|
+
/* Creating/destroying pools */
|
841
|
+
rb_define_method(c_storage_pool, "build", libvirt_storage_pool_build, -1);
|
842
|
+
rb_define_method(c_storage_pool, "undefine", libvirt_storage_pool_undefine,
|
843
|
+
0);
|
844
|
+
rb_define_method(c_storage_pool, "create", libvirt_storage_pool_create, -1);
|
845
|
+
rb_define_method(c_storage_pool, "destroy", libvirt_storage_pool_destroy,
|
846
|
+
0);
|
847
|
+
rb_define_method(c_storage_pool, "delete", libvirt_storage_pool_delete, -1);
|
848
|
+
rb_define_method(c_storage_pool, "refresh", libvirt_storage_pool_refresh,
|
849
|
+
-1);
|
850
|
+
/* StoragePool information */
|
851
|
+
rb_define_method(c_storage_pool, "name", libvirt_storage_pool_name, 0);
|
852
|
+
rb_define_method(c_storage_pool, "uuid", libvirt_storage_pool_uuid, 0);
|
853
|
+
rb_define_method(c_storage_pool, "info", libvirt_storage_pool_info, 0);
|
854
|
+
rb_define_method(c_storage_pool, "xml_desc", libvirt_storage_pool_xml_desc,
|
855
|
+
-1);
|
856
|
+
rb_define_method(c_storage_pool, "autostart",
|
857
|
+
libvirt_storage_pool_autostart, 0);
|
858
|
+
rb_define_method(c_storage_pool, "autostart?",
|
859
|
+
libvirt_storage_pool_autostart, 0);
|
860
|
+
rb_define_method(c_storage_pool, "autostart=",
|
861
|
+
libvirt_storage_pool_autostart_equal, 1);
|
862
|
+
/* List/lookup storage volumes within a pool */
|
863
|
+
rb_define_method(c_storage_pool, "num_of_volumes",
|
864
|
+
libvirt_storage_pool_num_of_volumes, 0);
|
865
|
+
rb_define_method(c_storage_pool, "list_volumes",
|
866
|
+
libvirt_storage_pool_list_volumes, 0);
|
867
|
+
/* Lookup volumes based on various attributes */
|
868
|
+
rb_define_method(c_storage_pool, "lookup_volume_by_name",
|
869
|
+
libvirt_storage_pool_lookup_vol_by_name, 1);
|
870
|
+
rb_define_method(c_storage_pool, "lookup_volume_by_key",
|
871
|
+
libvirt_storage_pool_lookup_vol_by_key, 1);
|
872
|
+
rb_define_method(c_storage_pool, "lookup_volume_by_path",
|
873
|
+
libvirt_storage_pool_lookup_vol_by_path, 1);
|
874
|
+
rb_define_method(c_storage_pool, "free", libvirt_storage_pool_free, 0);
|
875
|
+
rb_define_method(c_storage_pool, "create_volume_xml",
|
876
|
+
libvirt_storage_pool_create_volume_xml, -1);
|
877
|
+
rb_define_alias(c_storage_pool, "create_vol_xml", "create_volume_xml");
|
878
|
+
#if HAVE_VIRSTORAGEVOLCREATEXMLFROM
|
879
|
+
rb_define_method(c_storage_pool, "create_volume_xml_from",
|
880
|
+
libvirt_storage_pool_create_volume_xml_from, -1);
|
881
|
+
rb_define_alias(c_storage_pool, "create_vol_xml_from",
|
882
|
+
"create_volume_xml_from");
|
883
|
+
#endif
|
884
|
+
#if HAVE_VIRSTORAGEPOOLISACTIVE
|
885
|
+
rb_define_method(c_storage_pool, "active?", libvirt_storage_pool_active_p,
|
886
|
+
0);
|
887
|
+
#endif
|
888
|
+
#if HAVE_VIRSTORAGEPOOLISPERSISTENT
|
889
|
+
rb_define_method(c_storage_pool, "persistent?",
|
890
|
+
libvirt_storage_pool_persistent_p, 0);
|
891
|
+
#endif
|
892
|
+
|
893
|
+
#if HAVE_VIRSTORAGEPOOLLISTALLVOLUMES
|
894
|
+
rb_define_method(c_storage_pool, "list_all_volumes",
|
895
|
+
libvirt_storage_pool_list_all_volumes, -1);
|
896
|
+
#endif
|
897
|
+
|
898
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_BUILD_NO_OVERWRITE
|
899
|
+
rb_define_const(c_storage_pool, "BUILD_NO_OVERWRITE",
|
900
|
+
INT2NUM(VIR_STORAGE_POOL_BUILD_NO_OVERWRITE));
|
901
|
+
#endif
|
902
|
+
|
903
|
+
#if HAVE_CONST_VIR_STORAGE_POOL_BUILD_OVERWRITE
|
904
|
+
rb_define_const(c_storage_pool, "BUILD_OVERWRITE",
|
905
|
+
INT2NUM(VIR_STORAGE_POOL_BUILD_OVERWRITE));
|
906
|
+
#endif
|
907
|
+
|
908
|
+
#endif
|
909
|
+
|
910
|
+
#if HAVE_TYPE_VIRSTORAGEVOLPTR
|
911
|
+
/*
|
912
|
+
* Class Libvirt::StorageVol and Libvirt::StorageVolInfo
|
913
|
+
*/
|
914
|
+
c_storage_vol_info = rb_define_class_under(m_libvirt, "StorageVolInfo",
|
915
|
+
rb_cObject);
|
916
|
+
rb_define_attr(c_storage_vol_info, "type", 1, 0);
|
917
|
+
rb_define_attr(c_storage_vol_info, "capacity", 1, 0);
|
918
|
+
rb_define_attr(c_storage_vol_info, "allocation", 1, 0);
|
919
|
+
|
920
|
+
c_storage_vol = rb_define_class_under(m_libvirt, "StorageVol",
|
921
|
+
rb_cObject);
|
922
|
+
|
923
|
+
#if HAVE_CONST_VIR_STORAGE_XML_INACTIVE
|
924
|
+
rb_define_const(c_storage_vol, "XML_INACTIVE",
|
925
|
+
INT2NUM(VIR_STORAGE_XML_INACTIVE));
|
926
|
+
#endif
|
927
|
+
|
928
|
+
/* virStorageVolType */
|
929
|
+
rb_define_const(c_storage_vol, "FILE", INT2NUM(VIR_STORAGE_VOL_FILE));
|
930
|
+
rb_define_const(c_storage_vol, "BLOCK", INT2NUM(VIR_STORAGE_VOL_BLOCK));
|
931
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_DIR
|
932
|
+
rb_define_const(c_storage_vol, "DIR", INT2NUM(VIR_STORAGE_VOL_DIR));
|
933
|
+
#endif
|
934
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_NETWORK
|
935
|
+
rb_define_const(c_storage_vol, "NETWORK", INT2NUM(VIR_STORAGE_VOL_NETWORK));
|
936
|
+
#endif
|
937
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_NETDIR
|
938
|
+
rb_define_const(c_storage_vol, "NETDIR", INT2NUM(VIR_STORAGE_VOL_NETDIR));
|
939
|
+
#endif
|
940
|
+
|
941
|
+
/* virStorageVolDeleteFlags */
|
942
|
+
rb_define_const(c_storage_vol, "DELETE_NORMAL",
|
943
|
+
INT2NUM(VIR_STORAGE_VOL_DELETE_NORMAL));
|
944
|
+
rb_define_const(c_storage_vol, "DELETE_ZEROED",
|
945
|
+
INT2NUM(VIR_STORAGE_VOL_DELETE_ZEROED));
|
946
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS
|
947
|
+
rb_define_const(c_storage_vol, "DELETE_WITH_SNAPSHOTS",
|
948
|
+
INT2NUM(VIR_STORAGE_VOL_DELETE_WITH_SNAPSHOTS));
|
949
|
+
#endif
|
950
|
+
|
951
|
+
rb_define_method(c_storage_vol, "pool", libvirt_storage_vol_pool, 0);
|
952
|
+
rb_define_method(c_storage_vol, "name", libvirt_storage_vol_name, 0);
|
953
|
+
rb_define_method(c_storage_vol, "key", libvirt_storage_vol_key, 0);
|
954
|
+
rb_define_method(c_storage_vol, "delete", libvirt_storage_vol_delete, -1);
|
955
|
+
#if HAVE_VIRSTORAGEVOLWIPE
|
956
|
+
rb_define_method(c_storage_vol, "wipe", libvirt_storage_vol_wipe, -1);
|
957
|
+
#endif
|
958
|
+
#if HAVE_VIRSTORAGEVOLWIPEPATTERN
|
959
|
+
rb_define_method(c_storage_vol, "wipe_pattern",
|
960
|
+
libvirt_storage_vol_wipe_pattern, -1);
|
961
|
+
#endif
|
962
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_ZERO
|
963
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_ZERO",
|
964
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_ZERO));
|
965
|
+
#endif
|
966
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_NNSA
|
967
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_NNSA",
|
968
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_NNSA));
|
969
|
+
#endif
|
970
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_DOD
|
971
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_DOD",
|
972
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_DOD));
|
973
|
+
#endif
|
974
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_BSI
|
975
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_BSI",
|
976
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_BSI));
|
977
|
+
#endif
|
978
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_GUTMANN
|
979
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_GUTMANN",
|
980
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_GUTMANN));
|
981
|
+
#endif
|
982
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER
|
983
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_SCHNEIER",
|
984
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER));
|
985
|
+
#endif
|
986
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7
|
987
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_PFITZNER7",
|
988
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7));
|
989
|
+
#endif
|
990
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33
|
991
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_PFITZNER33",
|
992
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33));
|
993
|
+
#endif
|
994
|
+
#if HAVE_CONST_VIR_STORAGE_VOL_WIPE_ALG_RANDOM
|
995
|
+
rb_define_const(c_storage_vol, "WIPE_ALG_RANDOM",
|
996
|
+
INT2NUM(VIR_STORAGE_VOL_WIPE_ALG_RANDOM));
|
997
|
+
#endif
|
998
|
+
|
999
|
+
rb_define_method(c_storage_vol, "info", libvirt_storage_vol_info, 0);
|
1000
|
+
rb_define_method(c_storage_vol, "xml_desc", libvirt_storage_vol_xml_desc,
|
1001
|
+
-1);
|
1002
|
+
rb_define_method(c_storage_vol, "path", libvirt_storage_vol_path, 0);
|
1003
|
+
rb_define_method(c_storage_vol, "free", libvirt_storage_vol_free, 0);
|
1004
|
+
|
1005
|
+
#if HAVE_VIRSTORAGEVOLDOWNLOAD
|
1006
|
+
rb_define_method(c_storage_vol, "download", libvirt_storage_vol_download,
|
1007
|
+
-1);
|
1008
|
+
rb_define_method(c_storage_vol, "upload", libvirt_storage_vol_upload, -1);
|
1009
|
+
#endif
|
1010
|
+
|
1011
|
+
#if HAVE_VIRSTORAGEVOLRESIZE
|
1012
|
+
rb_define_const(c_storage_vol, "RESIZE_ALLOCATE",
|
1013
|
+
INT2NUM(VIR_STORAGE_VOL_RESIZE_ALLOCATE));
|
1014
|
+
rb_define_const(c_storage_vol, "RESIZE_DELTA",
|
1015
|
+
INT2NUM(VIR_STORAGE_VOL_RESIZE_DELTA));
|
1016
|
+
rb_define_const(c_storage_vol, "RESIZE_SHRINK",
|
1017
|
+
INT2NUM(VIR_STORAGE_VOL_RESIZE_SHRINK));
|
1018
|
+
rb_define_method(c_storage_vol, "resize", libvirt_storage_vol_resize, -1);
|
1019
|
+
#endif
|
1020
|
+
|
1021
|
+
#endif
|
1022
|
+
}
|