ruby-libvirt-catphish 0.7.1

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,285 @@
1
+ #ifndef COMMON_H
2
+ #define COMMON_H
3
+
4
+ /* Macros to ease some of the boilerplate */
5
+ VALUE ruby_libvirt_new_class(VALUE klass, void *ptr, VALUE conn,
6
+ RUBY_DATA_FUNC free_func);
7
+
8
+ #define RUBY_LIBVIRT_UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
9
+
10
+ #define ruby_libvirt_get_struct(kind, v) \
11
+ do { \
12
+ vir##kind##Ptr ptr; \
13
+ Data_Get_Struct(v, vir##kind, ptr); \
14
+ if (!ptr) { \
15
+ rb_raise(rb_eArgError, #kind " has been freed"); \
16
+ } \
17
+ return ptr; \
18
+ } while (0);
19
+
20
+ #define ruby_libvirt_free_struct(kind, p) \
21
+ do { \
22
+ int r; \
23
+ r = vir##kind##Free((vir##kind##Ptr) p); \
24
+ if (r < 0) { \
25
+ rb_raise(rb_eSystemCallError, # kind " free failed"); \
26
+ } \
27
+ } while(0);
28
+
29
+ void ruby_libvirt_raise_error_if(const int condition, VALUE error,
30
+ const char *method, virConnectPtr conn);
31
+
32
+ /*
33
+ * Code generating macros.
34
+ *
35
+ * We only generate function bodies, not the whole function
36
+ * declaration.
37
+ */
38
+
39
+ /* Generate a call to a function FUNC which returns a string. The Ruby
40
+ * function will return the string on success and throw an exception on
41
+ * error. The string returned by FUNC is freed if dealloc is true.
42
+ */
43
+ #define ruby_libvirt_generate_call_string(func, conn, dealloc, args...) \
44
+ do { \
45
+ const char *str; \
46
+ VALUE result; \
47
+ int exception; \
48
+ \
49
+ str = func(args); \
50
+ ruby_libvirt_raise_error_if(str == NULL, e_Error, # func, conn); \
51
+ if (dealloc) { \
52
+ result = rb_protect(ruby_libvirt_str_new2_wrap, (VALUE)&str, &exception); \
53
+ xfree((void *) str); \
54
+ if (exception) { \
55
+ rb_jump_tag(exception); \
56
+ } \
57
+ } \
58
+ else { \
59
+ result = rb_str_new2(str); \
60
+ } \
61
+ return result; \
62
+ } while(0)
63
+
64
+ /* Generate a call to vir##KIND##Free and return Qnil. Set the the embedded
65
+ * vir##KIND##Ptr to NULL. If that pointer is already NULL, do nothing.
66
+ */
67
+ #define ruby_libvirt_generate_call_free(kind, s) \
68
+ do { \
69
+ vir##kind##Ptr ptr; \
70
+ Data_Get_Struct(s, vir##kind, ptr); \
71
+ if (ptr != NULL) { \
72
+ int r = vir##kind##Free(ptr); \
73
+ ruby_libvirt_raise_error_if(r < 0, e_Error, "vir" #kind "Free", ruby_libvirt_connect_get(s)); \
74
+ DATA_PTR(s) = NULL; \
75
+ } \
76
+ return Qnil; \
77
+ } while (0)
78
+
79
+ /* Generate a call to a function FUNC which returns an int error, where -1
80
+ * indicates error and 0 success. The Ruby function will return Qnil on
81
+ * success and throw an exception on error.
82
+ */
83
+ #define ruby_libvirt_generate_call_nil(func, conn, args...) \
84
+ do { \
85
+ int _r_##func; \
86
+ _r_##func = func(args); \
87
+ ruby_libvirt_raise_error_if(_r_##func < 0, e_Error, #func, conn); \
88
+ return Qnil; \
89
+ } while(0)
90
+
91
+ /* Generate a call to a function FUNC which returns an int; -1 indicates
92
+ * error, 0 indicates Qfalse, and 1 indicates Qtrue.
93
+ */
94
+ #define ruby_libvirt_generate_call_truefalse(func, conn, args...) \
95
+ do { \
96
+ int _r_##func; \
97
+ _r_##func = func(args); \
98
+ ruby_libvirt_raise_error_if(_r_##func < 0, e_Error, #func, conn); \
99
+ return _r_##func ? Qtrue : Qfalse; \
100
+ } while(0)
101
+
102
+ /* Generate a call to a function FUNC which returns an int error, where -1
103
+ * indicates error and >= 0 success. The Ruby function will return the integer
104
+ * success and throw an exception on error.
105
+ */
106
+ #define ruby_libvirt_generate_call_int(func, conn, args...) \
107
+ do { \
108
+ int _r_##func; \
109
+ _r_##func = func(args); \
110
+ ruby_libvirt_raise_error_if(_r_##func < 0, e_RetrieveError, #func, conn); \
111
+ return INT2NUM(_r_##func); \
112
+ } while(0)
113
+
114
+ #define ruby_libvirt_generate_uuid(func, conn, obj) \
115
+ do { \
116
+ char uuid[VIR_UUID_STRING_BUFLEN]; \
117
+ int _r_##func; \
118
+ _r_##func = func(obj, uuid); \
119
+ ruby_libvirt_raise_error_if(_r_##func < 0, e_RetrieveError, #func, conn); \
120
+ return rb_str_new2((char *) uuid); \
121
+ } while (0)
122
+
123
+
124
+ #define ruby_libvirt_generate_call_list_all(type, argc, argv, listfunc, object, val, newfunc, freefunc) \
125
+ do { \
126
+ VALUE flags = RUBY_Qnil; \
127
+ type *list; \
128
+ int i; \
129
+ int ret; \
130
+ VALUE result; \
131
+ int exception = 0; \
132
+ struct ruby_libvirt_ary_push_arg arg; \
133
+ \
134
+ rb_scan_args(argc, argv, "01", &flags); \
135
+ ret = listfunc(object, &list, ruby_libvirt_value_to_uint(flags)); \
136
+ ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, #listfunc, ruby_libvirt_connect_get(val)); \
137
+ result = rb_protect(ruby_libvirt_ary_new2_wrap, (VALUE)&ret, &exception); \
138
+ if (exception) { \
139
+ goto exception; \
140
+ } \
141
+ for (i = 0; i < ret; i++) { \
142
+ arg.arr = result; \
143
+ arg.value = newfunc(list[i], val); \
144
+ rb_protect(ruby_libvirt_ary_push_wrap, (VALUE)&arg, &exception); \
145
+ if (exception) { \
146
+ goto exception; \
147
+ } \
148
+ } \
149
+ \
150
+ free(list); \
151
+ \
152
+ return result; \
153
+ \
154
+ exception: \
155
+ for (i = 0; i < ret; i++) { \
156
+ freefunc(list[i]); \
157
+ } \
158
+ free(list); \
159
+ rb_jump_tag(exception); \
160
+ \
161
+ /* not needed, but here to shut the compiler up */ \
162
+ return Qnil; \
163
+ } while(0)
164
+
165
+ int ruby_libvirt_is_symbol_or_proc(VALUE handle);
166
+
167
+ extern VALUE e_RetrieveError;
168
+ extern VALUE e_Error;
169
+ extern VALUE e_DefinitionError;
170
+ extern VALUE e_NoSupportError;
171
+
172
+ extern VALUE m_libvirt;
173
+
174
+ char *ruby_libvirt_get_cstring_or_null(VALUE arg);
175
+
176
+ VALUE ruby_libvirt_generate_list(int num, char **list);
177
+
178
+ VALUE ruby_libvirt_get_parameters(VALUE d, unsigned int flags, void *opaque,
179
+ unsigned int typesize,
180
+ const char *(*nparams_cb)(VALUE d,
181
+ unsigned int flags,
182
+ void *opaque,
183
+ int *nparams),
184
+ const char *(*get_cb)(VALUE d,
185
+ unsigned int flags,
186
+ void *voidparams,
187
+ int *nparams,
188
+ void *opaque),
189
+ void (*hash_set)(void *voidparams, int i,
190
+ VALUE result));
191
+ VALUE ruby_libvirt_get_typed_parameters(VALUE d, unsigned int flags,
192
+ void *opaque,
193
+ const char *(*nparams_cb)(VALUE d,
194
+ unsigned int flags,
195
+ void *opaque,
196
+ int *nparams),
197
+ const char *(*get_cb)(VALUE d,
198
+ unsigned int flags,
199
+ void *params,
200
+ int *nparams,
201
+ void *opaque));
202
+ struct ruby_libvirt_typed_param {
203
+ const char *name;
204
+ int type;
205
+ };
206
+ struct ruby_libvirt_parameter_assign_args {
207
+ struct ruby_libvirt_typed_param *allowed;
208
+ unsigned int num_allowed;
209
+
210
+ virTypedParameter *params;
211
+ int i;
212
+ };
213
+ int ruby_libvirt_typed_parameter_assign(VALUE key, VALUE val, VALUE in);
214
+ VALUE ruby_libvirt_set_typed_parameters(VALUE d, VALUE input,
215
+ unsigned int flags, void *opaque,
216
+ struct ruby_libvirt_typed_param *allowed,
217
+ unsigned int num_allowed,
218
+ const char *(*set_cb)(VALUE d,
219
+ unsigned int flags,
220
+ virTypedParameterPtr params,
221
+ int nparams,
222
+ void *opaque));
223
+
224
+ int ruby_libvirt_get_maxcpus(virConnectPtr conn);
225
+
226
+ void ruby_libvirt_typed_params_to_hash(void *voidparams, int i, VALUE hash);
227
+ void ruby_libvirt_assign_hash_and_flags(VALUE in, VALUE *hash, VALUE *flags);
228
+
229
+ unsigned int ruby_libvirt_value_to_uint(VALUE in);
230
+ int ruby_libvirt_value_to_int(VALUE in);
231
+ unsigned long ruby_libvirt_value_to_ulong(VALUE in);
232
+ unsigned long long ruby_libvirt_value_to_ulonglong(VALUE in);
233
+
234
+ VALUE ruby_libvirt_ary_new2_wrap(VALUE arg);
235
+
236
+ struct ruby_libvirt_ary_push_arg {
237
+ VALUE arr;
238
+ VALUE value;
239
+ };
240
+ VALUE ruby_libvirt_ary_push_wrap(VALUE arg);
241
+
242
+ struct ruby_libvirt_ary_store_arg {
243
+ VALUE arr;
244
+ long index;
245
+ VALUE elem;
246
+ };
247
+ VALUE ruby_libvirt_ary_store_wrap(VALUE arg);
248
+
249
+ VALUE ruby_libvirt_str_new2_wrap(VALUE arg);
250
+
251
+ struct ruby_libvirt_str_new_arg {
252
+ char *val;
253
+ size_t size;
254
+ };
255
+ VALUE ruby_libvirt_str_new_wrap(VALUE arg);
256
+
257
+ struct ruby_libvirt_hash_aset_arg {
258
+ VALUE hash;
259
+ const char *name;
260
+ VALUE val;
261
+ };
262
+ VALUE ruby_libvirt_hash_aset_wrap(VALUE arg);
263
+
264
+ struct ruby_libvirt_str_new2_and_ary_store_arg {
265
+ VALUE arr;
266
+ long index;
267
+ char *value;
268
+ };
269
+ VALUE ruby_libvirt_str_new2_and_ary_store_wrap(VALUE arg);
270
+
271
+ #ifndef RARRAY_LEN
272
+ #define RARRAY_LEN(ar) (RARRAY(ar)->len)
273
+ #endif
274
+
275
+ #ifndef RSTRING_PTR
276
+ #define RSTRING_PTR(str) (RSTRING(str)->ptr)
277
+ #endif
278
+
279
+ #ifndef RSTRING_LEN
280
+ #define RSTRING_LEN(str) (RSTRING(str)->len)
281
+ #endif
282
+
283
+ #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
284
+
285
+ #endif
@@ -0,0 +1,3501 @@
1
+ /*
2
+ * connect.c: virConnect 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
+ #if HAVE_VIRDOMAINQEMUATTACH
25
+ #include <libvirt/libvirt-qemu.h>
26
+ #endif
27
+ #include <libvirt/virterror.h>
28
+ #include "extconf.h"
29
+ #include "common.h"
30
+ #include "domain.h"
31
+ #include "network.h"
32
+ #include "interface.h"
33
+ #include "nodedevice.h"
34
+ #include "nwfilter.h"
35
+ #include "secret.h"
36
+ #include "stream.h"
37
+
38
+ /*
39
+ * Generate a call to a virConnectNumOf... function. C is the Ruby VALUE
40
+ * holding the connection and OBJS is a token indicating what objects to
41
+ * get the number of, e.g. 'Domains'
42
+ */
43
+ #define gen_conn_num_of(c, objs) \
44
+ do { \
45
+ int r; \
46
+ r = virConnectNumOf##objs(ruby_libvirt_connect_get(c)); \
47
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virConnectNumOf" # objs, ruby_libvirt_connect_get(c)); \
48
+ return INT2NUM(r); \
49
+ } while(0)
50
+
51
+ /*
52
+ * Generate a call to a virConnectList... function. C is the Ruby VALUE
53
+ * holding the connection and OBJS is a token indicating what objects to
54
+ * get the number of, e.g. 'Domains' The list function must return an array
55
+ * of strings, which is returned as a Ruby array
56
+ */
57
+ #define gen_conn_list_names(c, objs) \
58
+ do { \
59
+ int r, num; \
60
+ char **names; \
61
+ num = virConnectNumOf##objs(ruby_libvirt_connect_get(c)); \
62
+ ruby_libvirt_raise_error_if(num < 0, e_RetrieveError, "virConnectNumOf" # objs, ruby_libvirt_connect_get(c)); \
63
+ if (num == 0) { \
64
+ /* if num is 0, don't call virConnectList* function */ \
65
+ return rb_ary_new2(num); \
66
+ } \
67
+ names = alloca(sizeof(char *) * num); \
68
+ r = virConnectList##objs(ruby_libvirt_connect_get(c), names, num); \
69
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virConnectList" # objs, ruby_libvirt_connect_get(c)); \
70
+ return ruby_libvirt_generate_list(r, names); \
71
+ } while(0)
72
+
73
+ static VALUE c_connect;
74
+ VALUE c_node_security_model;
75
+ static VALUE c_node_info;
76
+
77
+ static void connect_close(void *c)
78
+ {
79
+ int r;
80
+
81
+ if (!c) {
82
+ return;
83
+ }
84
+ r = virConnectClose((virConnectPtr) c);
85
+ ruby_libvirt_raise_error_if(r < 0, rb_eSystemCallError, "virConnectClose",
86
+ c);
87
+ }
88
+
89
+ VALUE ruby_libvirt_connect_new(virConnectPtr c)
90
+ {
91
+ return Data_Wrap_Struct(c_connect, NULL, connect_close, c);
92
+ }
93
+
94
+ VALUE ruby_libvirt_conn_attr(VALUE c)
95
+ {
96
+ if (rb_obj_is_instance_of(c, c_connect) != Qtrue) {
97
+ c = rb_iv_get(c, "@connection");
98
+ }
99
+ if (rb_obj_is_instance_of(c, c_connect) != Qtrue) {
100
+ rb_raise(rb_eArgError, "Expected Connection object");
101
+ }
102
+ return c;
103
+ }
104
+
105
+ virConnectPtr ruby_libvirt_connect_get(VALUE c)
106
+ {
107
+ c = ruby_libvirt_conn_attr(c);
108
+ ruby_libvirt_get_struct(Connect, c);
109
+ }
110
+
111
+ /*
112
+ * call-seq:
113
+ * conn.close -> nil
114
+ *
115
+ * Call virConnectClose[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectClose]
116
+ * to close the connection.
117
+ */
118
+ static VALUE libvirt_connect_close(VALUE c)
119
+ {
120
+ virConnectPtr conn;
121
+
122
+ Data_Get_Struct(c, virConnect, conn);
123
+ if (conn) {
124
+ connect_close(conn);
125
+ DATA_PTR(c) = NULL;
126
+ }
127
+ return Qnil;
128
+ }
129
+
130
+ /*
131
+ * call-seq:
132
+ * conn.closed? -> [True|False]
133
+ *
134
+ * Return +true+ if the connection is closed, +false+ if it is open.
135
+ */
136
+ static VALUE libvirt_connect_closed_p(VALUE c)
137
+ {
138
+ virConnectPtr conn;
139
+
140
+ Data_Get_Struct(c, virConnect, conn);
141
+ return (conn == NULL) ? Qtrue : Qfalse;
142
+ }
143
+
144
+ /*
145
+ * call-seq:
146
+ * conn.type -> String
147
+ *
148
+ * Call virConnectGetType[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetType]
149
+ * to retrieve the type of hypervisor for this connection.
150
+ */
151
+ static VALUE libvirt_connect_type(VALUE c)
152
+ {
153
+ ruby_libvirt_generate_call_string(virConnectGetType,
154
+ ruby_libvirt_connect_get(c), 0,
155
+ ruby_libvirt_connect_get(c));
156
+ }
157
+
158
+ /*
159
+ * call-seq:
160
+ * conn.version -> Fixnum
161
+ *
162
+ * Call virConnectGetVersion[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetVersion]
163
+ * to retrieve the version of the hypervisor for this connection.
164
+ */
165
+ static VALUE libvirt_connect_version(VALUE c)
166
+ {
167
+ int r;
168
+ unsigned long v;
169
+
170
+ r = virConnectGetVersion(ruby_libvirt_connect_get(c), &v);
171
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virConnectGetVersion",
172
+ ruby_libvirt_connect_get(c));
173
+
174
+ return ULONG2NUM(v);
175
+ }
176
+
177
+ #if HAVE_VIRCONNECTGETLIBVERSION
178
+ /*
179
+ * call-seq:
180
+ * conn.libversion -> Fixnum
181
+ *
182
+ * Call virConnectGetLibVersion[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetLibVersion]
183
+ * to retrieve the version of the libvirt library for this connection.
184
+ */
185
+ static VALUE libvirt_connect_libversion(VALUE c)
186
+ {
187
+ int r;
188
+ unsigned long v;
189
+
190
+ r = virConnectGetLibVersion(ruby_libvirt_connect_get(c), &v);
191
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
192
+ "virConnectGetLibVersion",
193
+ ruby_libvirt_connect_get(c));
194
+
195
+ return ULONG2NUM(v);
196
+ }
197
+ #endif
198
+
199
+ /*
200
+ * call-seq:
201
+ * conn.hostname -> String
202
+ *
203
+ * Call virConnectGetHostname[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetHostname]
204
+ * to retrieve the hostname of the hypervisor for this connection.
205
+ */
206
+ static VALUE libvirt_connect_hostname(VALUE c)
207
+ {
208
+ ruby_libvirt_generate_call_string(virConnectGetHostname,
209
+ ruby_libvirt_connect_get(c), 1,
210
+ ruby_libvirt_connect_get(c));
211
+ }
212
+
213
+ /*
214
+ * call-seq:
215
+ * conn.uri -> String
216
+ *
217
+ * Call virConnectGetURI[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetURI]
218
+ * to retrieve the canonical URI for this connection.
219
+ */
220
+ static VALUE libvirt_connect_uri(VALUE c)
221
+ {
222
+ ruby_libvirt_generate_call_string(virConnectGetURI,
223
+ ruby_libvirt_connect_get(c), 1,
224
+ ruby_libvirt_connect_get(c));
225
+ }
226
+
227
+ /*
228
+ * call-seq:
229
+ * conn.max_vcpus(type=nil) -> Fixnum
230
+ *
231
+ * Call virConnectGetMaxVcpus[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetMaxVcpus]
232
+ * to retrieve the maximum number of virtual cpus supported by the hypervisor
233
+ * for this connection.
234
+ */
235
+ static VALUE libvirt_connect_max_vcpus(int argc, VALUE *argv, VALUE c)
236
+ {
237
+ VALUE type;
238
+
239
+ rb_scan_args(argc, argv, "01", &type);
240
+
241
+ ruby_libvirt_generate_call_int(virConnectGetMaxVcpus,
242
+ ruby_libvirt_connect_get(c),
243
+ ruby_libvirt_connect_get(c),
244
+ ruby_libvirt_get_cstring_or_null(type));
245
+ }
246
+
247
+ /*
248
+ * call-seq:
249
+ * conn.node_info -> Libvirt::Connect::Nodeinfo
250
+ *
251
+ * Call virNodeGetInfo[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetInfo]
252
+ * to retrieve information about the node for this connection.
253
+ */
254
+ static VALUE libvirt_connect_node_info(VALUE c)
255
+ {
256
+ int r;
257
+ virNodeInfo nodeinfo;
258
+ VALUE result;
259
+
260
+ r = virNodeGetInfo(ruby_libvirt_connect_get(c), &nodeinfo);
261
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virNodeGetInfo",
262
+ ruby_libvirt_connect_get(c));
263
+
264
+ result = rb_class_new_instance(0, NULL, c_node_info);
265
+ rb_iv_set(result, "@model", rb_str_new2(nodeinfo.model));
266
+ rb_iv_set(result, "@memory", ULONG2NUM(nodeinfo.memory));
267
+ rb_iv_set(result, "@cpus", UINT2NUM(nodeinfo.cpus));
268
+ rb_iv_set(result, "@mhz", UINT2NUM(nodeinfo.mhz));
269
+ rb_iv_set(result, "@nodes", UINT2NUM(nodeinfo.nodes));
270
+ rb_iv_set(result, "@sockets", UINT2NUM(nodeinfo.sockets));
271
+ rb_iv_set(result, "@cores", UINT2NUM(nodeinfo.cores));
272
+ rb_iv_set(result, "@threads", UINT2NUM(nodeinfo.threads));
273
+
274
+ return result;
275
+ }
276
+
277
+ /*
278
+ * call-seq:
279
+ * conn.node_free_memory -> Fixnum
280
+ *
281
+ * Call virNodeGetFreeMemory[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetFreeMemory]
282
+ * to retrieve the amount of free memory available on the host for this
283
+ * connection.
284
+ */
285
+ static VALUE libvirt_connect_node_free_memory(VALUE c)
286
+ {
287
+ unsigned long long freemem;
288
+
289
+ freemem = virNodeGetFreeMemory(ruby_libvirt_connect_get(c));
290
+
291
+ ruby_libvirt_raise_error_if(freemem == 0, e_RetrieveError,
292
+ "virNodeGetFreeMemory",
293
+ ruby_libvirt_connect_get(c));
294
+
295
+ return ULL2NUM(freemem);
296
+ }
297
+
298
+ /*
299
+ * call-seq:
300
+ * conn.node_cells_free_memory(startCell=0, maxCells=#nodeCells) -> list
301
+ *
302
+ * Call virNodeGetCellsFreeMemory[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetCellsFreeMemory]
303
+ * to retrieve the amount of free memory in each NUMA cell on the host for
304
+ * this connection.
305
+ */
306
+ static VALUE libvirt_connect_node_cells_free_memory(int argc, VALUE *argv,
307
+ VALUE c)
308
+ {
309
+ int i, r;
310
+ VALUE cells, start, max;
311
+ unsigned long long *freeMems;
312
+ virNodeInfo nodeinfo;
313
+ unsigned int startCell, maxCells;
314
+
315
+ rb_scan_args(argc, argv, "02", &start, &max);
316
+
317
+ if (NIL_P(start)) {
318
+ startCell = 0;
319
+ }
320
+ else {
321
+ startCell = NUM2UINT(start);
322
+ }
323
+
324
+ if (NIL_P(max)) {
325
+ r = virNodeGetInfo(ruby_libvirt_connect_get(c), &nodeinfo);
326
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virNodeGetInfo",
327
+ ruby_libvirt_connect_get(c));
328
+ maxCells = nodeinfo.nodes;
329
+ }
330
+ else {
331
+ maxCells = NUM2UINT(max);
332
+ }
333
+
334
+ freeMems = alloca(sizeof(unsigned long long) * maxCells);
335
+
336
+ r = virNodeGetCellsFreeMemory(ruby_libvirt_connect_get(c), freeMems,
337
+ startCell, maxCells);
338
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
339
+ "virNodeGetCellsFreeMemory",
340
+ ruby_libvirt_connect_get(c));
341
+
342
+ cells = rb_ary_new2(r);
343
+ for (i = 0; i < r; i++) {
344
+ rb_ary_store(cells, i, ULL2NUM(freeMems[i]));
345
+ }
346
+
347
+ return cells;
348
+ }
349
+
350
+ #if HAVE_VIRNODEGETSECURITYMODEL
351
+ /*
352
+ * call-seq:
353
+ * conn.node_security_model -> Libvirt::Connect::NodeSecurityModel
354
+ *
355
+ * Call virNodeGetSecurityModel[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetSecurityModel]
356
+ * to retrieve the security model in use on the host for this connection.
357
+ */
358
+ static VALUE libvirt_connect_node_security_model(VALUE c)
359
+ {
360
+ virSecurityModel secmodel;
361
+ int r;
362
+ VALUE result;
363
+
364
+ r = virNodeGetSecurityModel(ruby_libvirt_connect_get(c), &secmodel);
365
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
366
+ "virNodeGetSecurityModel",
367
+ ruby_libvirt_connect_get(c));
368
+
369
+ result = rb_class_new_instance(0, NULL, c_node_security_model);
370
+ rb_iv_set(result, "@model", rb_str_new2(secmodel.model));
371
+ rb_iv_set(result, "@doi", rb_str_new2(secmodel.doi));
372
+
373
+ return result;
374
+ }
375
+ #endif
376
+
377
+ #if HAVE_VIRCONNECTISENCRYPTED
378
+ /*
379
+ * call-seq:
380
+ * conn.encrypted? -> [True|False]
381
+ *
382
+ * Call virConnectIsEncrypted[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectIsEncrypted]
383
+ * to determine if the connection is encrypted.
384
+ */
385
+ static VALUE libvirt_connect_encrypted_p(VALUE c)
386
+ {
387
+ ruby_libvirt_generate_call_truefalse(virConnectIsEncrypted,
388
+ ruby_libvirt_connect_get(c),
389
+ ruby_libvirt_connect_get(c));
390
+ }
391
+ #endif
392
+
393
+ #if HAVE_VIRCONNECTISSECURE
394
+ /*
395
+ * call-seq:
396
+ * conn.secure? -> [True|False]
397
+ *
398
+ * Call virConnectIsSecure[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectIsSecure]
399
+ * to determine if the connection is secure.
400
+ */
401
+ static VALUE libvirt_connect_secure_p(VALUE c)
402
+ {
403
+ ruby_libvirt_generate_call_truefalse(virConnectIsSecure,
404
+ ruby_libvirt_connect_get(c),
405
+ ruby_libvirt_connect_get(c));
406
+ }
407
+ #endif
408
+
409
+ /*
410
+ * call-seq:
411
+ * conn.capabilities -> String
412
+ *
413
+ * Call virConnectGetCapabilities[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetCapabilities]
414
+ * to retrieve the capabilities XML for this connection.
415
+ */
416
+ static VALUE libvirt_connect_capabilities(VALUE c)
417
+ {
418
+ ruby_libvirt_generate_call_string(virConnectGetCapabilities,
419
+ ruby_libvirt_connect_get(c), 1,
420
+ ruby_libvirt_connect_get(c));
421
+ }
422
+
423
+ #if HAVE_VIRCONNECTCOMPARECPU
424
+ /*
425
+ * call-seq:
426
+ * conn.compare_cpu(xml, flags=0) -> compareflag
427
+ *
428
+ * Call virConnectCompareCPU[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectCompareCPU]
429
+ * to compare the host CPU with the XML contained in xml. Returns one of
430
+ * Libvirt::CPU_COMPARE_ERROR, Libvirt::CPU_COMPARE_INCOMPATIBLE,
431
+ * Libvirt::CPU_COMPARE_IDENTICAL, or Libvirt::CPU_COMPARE_SUPERSET.
432
+ */
433
+ static VALUE libvirt_connect_compare_cpu(int argc, VALUE *argv, VALUE c)
434
+ {
435
+ VALUE xml, flags;
436
+
437
+ rb_scan_args(argc, argv, "11", &xml, &flags);
438
+
439
+ ruby_libvirt_generate_call_int(virConnectCompareCPU,
440
+ ruby_libvirt_connect_get(c),
441
+ ruby_libvirt_connect_get(c),
442
+ StringValueCStr(xml),
443
+ ruby_libvirt_value_to_uint(flags));
444
+ }
445
+ #endif
446
+
447
+
448
+ #if HAVE_VIRCONNECTBASELINECPU
449
+ /*
450
+ * call-seq:
451
+ * conn.baseline_cpu([xml, xml2, ...], flags=0) -> XML
452
+ *
453
+ * Call virConnectBaselineCPU[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectBaselineCPU]
454
+ * to compare the most feature-rich CPU which is compatible with all
455
+ * given host CPUs.
456
+ */
457
+ static VALUE libvirt_connect_baseline_cpu(int argc, VALUE *argv, VALUE c)
458
+ {
459
+ VALUE xmlcpus, flags, retval, entry;
460
+ char *r;
461
+ unsigned int ncpus;
462
+ const char **xmllist;
463
+ int exception = 0;
464
+ unsigned int i;
465
+
466
+ rb_scan_args(argc, argv, "11", &xmlcpus, &flags);
467
+
468
+ Check_Type(xmlcpus, T_ARRAY);
469
+
470
+ if (RARRAY_LEN(xmlcpus) < 1) {
471
+ rb_raise(rb_eArgError,
472
+ "wrong number of cpu arguments (%ld for 1 or more)",
473
+ RARRAY_LEN(xmlcpus));
474
+ }
475
+
476
+ ncpus = RARRAY_LEN(xmlcpus);
477
+ xmllist = alloca(sizeof(const char *) * ncpus);
478
+
479
+ for (i = 0; i < ncpus; i++) {
480
+ entry = rb_ary_entry(xmlcpus, i);
481
+ xmllist[i] = StringValueCStr(entry);
482
+ }
483
+
484
+ r = virConnectBaselineCPU(ruby_libvirt_connect_get(c), xmllist, ncpus,
485
+ ruby_libvirt_value_to_uint(flags));
486
+ ruby_libvirt_raise_error_if(r == NULL, e_RetrieveError,
487
+ "virConnectBaselineCPU",
488
+ ruby_libvirt_connect_get(c));
489
+
490
+ retval = rb_protect(ruby_libvirt_str_new2_wrap, (VALUE)&r, &exception);
491
+ free(r);
492
+ if (exception) {
493
+ rb_jump_tag(exception);
494
+ }
495
+
496
+ return retval;
497
+ }
498
+ #endif
499
+
500
+ #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY || HAVE_VIRCONNECTDOMAINEVENTREGISTER
501
+ static int domain_event_lifecycle_callback(virConnectPtr conn,
502
+ virDomainPtr dom, int event,
503
+ int detail, void *opaque)
504
+ {
505
+ VALUE passthrough = (VALUE)opaque;
506
+ VALUE cb, cb_opaque, newc;
507
+
508
+ Check_Type(passthrough, T_ARRAY);
509
+
510
+ if (RARRAY_LEN(passthrough) != 2) {
511
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
512
+ RARRAY_LEN(passthrough));
513
+ }
514
+
515
+ cb = rb_ary_entry(passthrough, 0);
516
+ cb_opaque = rb_ary_entry(passthrough, 1);
517
+
518
+ newc = ruby_libvirt_connect_new(conn);
519
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
520
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 5, newc,
521
+ ruby_libvirt_domain_new(dom, newc), INT2NUM(event),
522
+ INT2NUM(detail), cb_opaque);
523
+ }
524
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
525
+ rb_funcall(cb, rb_intern("call"), 5, newc,
526
+ ruby_libvirt_domain_new(dom, newc), INT2NUM(event),
527
+ INT2NUM(detail), cb_opaque);
528
+ }
529
+ else {
530
+ rb_raise(rb_eTypeError,
531
+ "wrong domain event lifecycle callback (expected Symbol or Proc)");
532
+ }
533
+
534
+ return 0;
535
+ }
536
+ #endif
537
+
538
+ #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY
539
+ static int domain_event_reboot_callback(virConnectPtr conn, virDomainPtr dom,
540
+ void *opaque)
541
+ {
542
+ VALUE passthrough = (VALUE)opaque;
543
+ VALUE cb, cb_opaque, newc;
544
+
545
+ Check_Type(passthrough, T_ARRAY);
546
+
547
+ if (RARRAY_LEN(passthrough) != 2) {
548
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
549
+ RARRAY_LEN(passthrough));
550
+ }
551
+
552
+ cb = rb_ary_entry(passthrough, 0);
553
+ cb_opaque = rb_ary_entry(passthrough, 1);
554
+
555
+ newc = ruby_libvirt_connect_new(conn);
556
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
557
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 3, newc,
558
+ ruby_libvirt_domain_new(dom, newc), cb_opaque);
559
+ }
560
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
561
+ rb_funcall(cb, rb_intern("call"), 3, newc,
562
+ ruby_libvirt_domain_new(dom, newc), cb_opaque);
563
+ }
564
+ else {
565
+ rb_raise(rb_eTypeError,
566
+ "wrong domain event reboot callback (expected Symbol or Proc)");
567
+ }
568
+
569
+ return 0;
570
+ }
571
+
572
+ static int domain_event_rtc_callback(virConnectPtr conn, virDomainPtr dom,
573
+ long long utc_offset, void *opaque)
574
+ {
575
+ VALUE passthrough = (VALUE)opaque;
576
+ VALUE cb, cb_opaque, newc;
577
+
578
+ Check_Type(passthrough, T_ARRAY);
579
+
580
+ if (RARRAY_LEN(passthrough) != 2) {
581
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
582
+ RARRAY_LEN(passthrough));
583
+ }
584
+
585
+ cb = rb_ary_entry(passthrough, 0);
586
+ cb_opaque = rb_ary_entry(passthrough, 1);
587
+
588
+ newc = ruby_libvirt_connect_new(conn);
589
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
590
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 4, newc,
591
+ ruby_libvirt_domain_new(dom, newc), LL2NUM(utc_offset),
592
+ cb_opaque);
593
+ }
594
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
595
+ rb_funcall(cb, rb_intern("call"), 4, newc,
596
+ ruby_libvirt_domain_new(dom, newc), LL2NUM(utc_offset),
597
+ cb_opaque);
598
+ }
599
+ else {
600
+ rb_raise(rb_eTypeError,
601
+ "wrong domain event rtc callback (expected Symbol or Proc)");
602
+ }
603
+
604
+ return 0;
605
+ }
606
+
607
+ static int domain_event_watchdog_callback(virConnectPtr conn, virDomainPtr dom,
608
+ int action, void *opaque)
609
+ {
610
+ VALUE passthrough = (VALUE)opaque;
611
+ VALUE cb, cb_opaque, newc;
612
+
613
+ Check_Type(passthrough, T_ARRAY);
614
+
615
+ if (RARRAY_LEN(passthrough) != 2) {
616
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
617
+ RARRAY_LEN(passthrough));
618
+ }
619
+
620
+ cb = rb_ary_entry(passthrough, 0);
621
+ cb_opaque = rb_ary_entry(passthrough, 1);
622
+
623
+ newc = ruby_libvirt_connect_new(conn);
624
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
625
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 4, newc,
626
+ ruby_libvirt_domain_new(dom, newc), INT2NUM(action),
627
+ cb_opaque);
628
+ }
629
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
630
+ rb_funcall(cb, rb_intern("call"), 4, newc,
631
+ ruby_libvirt_domain_new(dom, newc), INT2NUM(action),
632
+ cb_opaque);
633
+ }
634
+ else {
635
+ rb_raise(rb_eTypeError,
636
+ "wrong domain event watchdog callback (expected Symbol or Proc)");
637
+ }
638
+
639
+ return 0;
640
+ }
641
+
642
+ static int domain_event_io_error_callback(virConnectPtr conn, virDomainPtr dom,
643
+ const char *src_path,
644
+ const char *dev_alias,
645
+ int action,
646
+ void *opaque)
647
+ {
648
+ VALUE passthrough = (VALUE)opaque;
649
+ VALUE cb, cb_opaque, newc;
650
+
651
+ Check_Type(passthrough, T_ARRAY);
652
+
653
+ if (RARRAY_LEN(passthrough) != 2) {
654
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
655
+ RARRAY_LEN(passthrough));
656
+ }
657
+
658
+ cb = rb_ary_entry(passthrough, 0);
659
+ cb_opaque = rb_ary_entry(passthrough, 1);
660
+
661
+ newc = ruby_libvirt_connect_new(conn);
662
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
663
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 6, newc,
664
+ ruby_libvirt_domain_new(dom, newc), rb_str_new2(src_path),
665
+ rb_str_new2(dev_alias), INT2NUM(action), cb_opaque);
666
+ }
667
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
668
+ rb_funcall(cb, rb_intern("call"), 6, newc,
669
+ ruby_libvirt_domain_new(dom, newc),
670
+ rb_str_new2(src_path), rb_str_new2(dev_alias),
671
+ INT2NUM(action), cb_opaque);
672
+ }
673
+ else {
674
+ rb_raise(rb_eTypeError,
675
+ "wrong domain event IO error callback (expected Symbol or Proc)");
676
+ }
677
+
678
+ return 0;
679
+ }
680
+
681
+ static int domain_event_io_error_reason_callback(virConnectPtr conn,
682
+ virDomainPtr dom,
683
+ const char *src_path,
684
+ const char *dev_alias,
685
+ int action,
686
+ const char *reason,
687
+ void *opaque)
688
+ {
689
+ VALUE passthrough = (VALUE)opaque;
690
+ VALUE cb, cb_opaque, newc;
691
+
692
+ Check_Type(passthrough, T_ARRAY);
693
+
694
+ if (RARRAY_LEN(passthrough) != 2) {
695
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
696
+ RARRAY_LEN(passthrough));
697
+ }
698
+
699
+ cb = rb_ary_entry(passthrough, 0);
700
+ cb_opaque = rb_ary_entry(passthrough, 1);
701
+
702
+ newc = ruby_libvirt_connect_new(conn);
703
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
704
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 7, newc,
705
+ ruby_libvirt_domain_new(dom, newc), rb_str_new2(src_path),
706
+ rb_str_new2(dev_alias), INT2NUM(action),
707
+ rb_str_new2(reason), cb_opaque);
708
+ }
709
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
710
+ rb_funcall(cb, rb_intern("call"), 7, newc,
711
+ ruby_libvirt_domain_new(dom, newc),
712
+ rb_str_new2(src_path), rb_str_new2(dev_alias),
713
+ INT2NUM(action), rb_str_new2(reason), cb_opaque);
714
+ }
715
+ else {
716
+ rb_raise(rb_eTypeError,
717
+ "wrong domain event IO error reason callback (expected Symbol or Proc)");
718
+ }
719
+
720
+ return 0;
721
+ }
722
+
723
+ static int domain_event_graphics_callback(virConnectPtr conn, virDomainPtr dom,
724
+ int phase,
725
+ virDomainEventGraphicsAddressPtr local,
726
+ virDomainEventGraphicsAddressPtr remote,
727
+ const char *authScheme,
728
+ virDomainEventGraphicsSubjectPtr subject,
729
+ void *opaque)
730
+ {
731
+ VALUE passthrough = (VALUE)opaque;
732
+ VALUE cb, cb_opaque, newc, local_hash, remote_hash, subject_array, pair;
733
+ int i;
734
+
735
+ Check_Type(passthrough, T_ARRAY);
736
+
737
+ if (RARRAY_LEN(passthrough) != 2) {
738
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
739
+ RARRAY_LEN(passthrough));
740
+ }
741
+
742
+ cb = rb_ary_entry(passthrough, 0);
743
+ cb_opaque = rb_ary_entry(passthrough, 1);
744
+
745
+ local_hash = rb_hash_new();
746
+ rb_hash_aset(local_hash, rb_str_new2("family"), INT2NUM(local->family));
747
+ rb_hash_aset(local_hash, rb_str_new2("node"), rb_str_new2(local->node));
748
+ rb_hash_aset(local_hash, rb_str_new2("service"),
749
+ rb_str_new2(local->service));
750
+
751
+ remote_hash = rb_hash_new();
752
+ rb_hash_aset(remote_hash, rb_str_new2("family"), INT2NUM(remote->family));
753
+ rb_hash_aset(remote_hash, rb_str_new2("node"), rb_str_new2(remote->node));
754
+ rb_hash_aset(remote_hash, rb_str_new2("service"),
755
+ rb_str_new2(remote->service));
756
+
757
+ subject_array = rb_ary_new();
758
+ for (i = 0; i < subject->nidentity; i++) {
759
+ pair = rb_ary_new();
760
+ rb_ary_store(pair, 0, rb_str_new2(subject->identities[i].type));
761
+ rb_ary_store(pair, 1, rb_str_new2(subject->identities[i].name));
762
+
763
+ rb_ary_store(subject_array, i, pair);
764
+ }
765
+
766
+ newc = ruby_libvirt_connect_new(conn);
767
+ if (strcmp(rb_obj_classname(cb), "Symbol") == 0) {
768
+ rb_funcall(rb_class_of(cb), rb_to_id(cb), 8, newc,
769
+ ruby_libvirt_domain_new(dom, newc), INT2NUM(phase),
770
+ local_hash, remote_hash, rb_str_new2(authScheme),
771
+ subject_array, cb_opaque);
772
+ }
773
+ else if (strcmp(rb_obj_classname(cb), "Proc") == 0) {
774
+ rb_funcall(cb, rb_intern("call"), 8, newc,
775
+ ruby_libvirt_domain_new(dom, newc), INT2NUM(phase),
776
+ local_hash, remote_hash, rb_str_new2(authScheme),
777
+ subject_array, cb_opaque);
778
+ }
779
+ else {
780
+ rb_raise(rb_eTypeError,
781
+ "wrong domain event graphics callback (expected Symbol or Proc)");
782
+ }
783
+
784
+ return 0;
785
+ }
786
+
787
+ /*
788
+ * call-seq:
789
+ * conn.domain_event_register_any(eventID, callback, dom=nil, opaque=nil) -> Fixnum
790
+ *
791
+ * Call virConnectDomainEventRegisterAny[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectDomainEventRegisterAny]
792
+ * to register callback for eventID with libvirt. The eventID must be one of
793
+ * the Libvirt::Connect::DOMAIN_EVENT_ID_* constants. The callback can either
794
+ * be a Symbol (that is the name of a method to callback) or a Proc. Note that
795
+ * the callback must accept different numbers of arguments depending on the
796
+ * eventID passed in. The arguments are as follows:
797
+ *
798
+ * - DOMAIN_EVENT_ID_LIFECYCLE: Libvirt::Connect, Libvirt::Domain, event, detail, opaque
799
+ * - DOMAIN_EVENT_ID_REBOOT: Libvirt::Connect, Libvirt::Domain, opaque
800
+ * - DOMAIN_EVENT_ID_RTC_CHANGE: Libvirt::Connect, Libvirt::Domain, utc_offset, opaque
801
+ * - DOMAIN_EVENT_ID_WATCHDOG: Libvirt::Connect, Libvirt::Domain, action, opaque
802
+ * - DOMAIN_EVENT_ID_IO_ERROR: Libvirt::Connect, Libvirt::Domain, src_path, dev_alias, action, opaque
803
+ * - DOMAIN_EVENT_ID_IO_ERROR_REASON: Libvirt::Connect, Libvirt::Domain, src_path, dev_alias, action, reason, opaque
804
+ * - DOMAIN_EVENT_ID_GRAPHICS: Libvirt::Connect, Libvirt::Domain, phase, local, remote, auth_scheme, subject, opaque
805
+
806
+ * If dom is a valid Libvirt::Domain object, then only events from that
807
+ * domain will be seen. The opaque parameter can be any valid ruby type, and
808
+ * will be passed into callback as "opaque". This method returns a
809
+ * libvirt-specific handle, which must be used by the application to
810
+ * deregister the callback later (see domain_event_deregister_any).
811
+ */
812
+ static VALUE libvirt_connect_domain_event_register_any(int argc, VALUE *argv,
813
+ VALUE c)
814
+ {
815
+ VALUE eventID, cb, dom, opaque, passthrough;
816
+ virDomainPtr domain;
817
+ virConnectDomainEventGenericCallback internalcb = NULL;
818
+
819
+ rb_scan_args(argc, argv, "22", &eventID, &cb, &dom, &opaque);
820
+
821
+ if (!ruby_libvirt_is_symbol_or_proc(cb)) {
822
+ rb_raise(rb_eTypeError,
823
+ "wrong argument type (expected Symbol or Proc)");
824
+ }
825
+
826
+ if (NIL_P(dom)) {
827
+ domain = NULL;
828
+ }
829
+ else {
830
+ domain = ruby_libvirt_domain_get(dom);
831
+ }
832
+
833
+ switch(NUM2INT(eventID)) {
834
+ case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
835
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_lifecycle_callback);
836
+ break;
837
+ case VIR_DOMAIN_EVENT_ID_REBOOT:
838
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_reboot_callback);
839
+ break;
840
+ case VIR_DOMAIN_EVENT_ID_RTC_CHANGE:
841
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_rtc_callback);
842
+ break;
843
+ case VIR_DOMAIN_EVENT_ID_WATCHDOG:
844
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_watchdog_callback);
845
+ break;
846
+ case VIR_DOMAIN_EVENT_ID_IO_ERROR:
847
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_io_error_callback);
848
+ break;
849
+ case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
850
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_io_error_reason_callback);
851
+ break;
852
+ case VIR_DOMAIN_EVENT_ID_GRAPHICS:
853
+ internalcb = VIR_DOMAIN_EVENT_CALLBACK(domain_event_graphics_callback);
854
+ break;
855
+ default:
856
+ rb_raise(rb_eArgError, "invalid eventID argument %d",
857
+ NUM2INT(eventID));
858
+ break;
859
+ }
860
+
861
+ passthrough = rb_ary_new();
862
+ rb_ary_store(passthrough, 0, cb);
863
+ rb_ary_store(passthrough, 1, opaque);
864
+
865
+ ruby_libvirt_generate_call_int(virConnectDomainEventRegisterAny,
866
+ ruby_libvirt_connect_get(c),
867
+ ruby_libvirt_connect_get(c), domain,
868
+ NUM2INT(eventID), internalcb,
869
+ (void *)passthrough, NULL);
870
+ }
871
+
872
+ /*
873
+ * call-seq:
874
+ * conn.domain_event_deregister_any(callbackID) -> nil
875
+ *
876
+ * Call virConnectDomainEventDeregisterAny[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectDomainEventDeregisterAny]
877
+ * to deregister a callback from libvirt. The callbackID must be a
878
+ * libvirt-specific handle returned by domain_event_register_any.
879
+ */
880
+ static VALUE libvirt_connect_domain_event_deregister_any(VALUE c,
881
+ VALUE callbackID)
882
+ {
883
+ ruby_libvirt_generate_call_nil(virConnectDomainEventDeregisterAny,
884
+ ruby_libvirt_connect_get(c),
885
+ ruby_libvirt_connect_get(c),
886
+ NUM2INT(callbackID));
887
+ }
888
+ #endif
889
+
890
+ #if HAVE_VIRCONNECTDOMAINEVENTREGISTER
891
+ /*
892
+ * this is a bit of silliness. Because libvirt internals track the address
893
+ * of the function pointer, trying to use domain_event_lifecycle_callback
894
+ * for both register and register_any would mean that we could only register
895
+ * one or the other for lifecycle callbacks. Instead we do a simple wrapper
896
+ * so that the addresses are different
897
+ */
898
+ static int domain_event_callback(virConnectPtr conn,
899
+ virDomainPtr dom, int event,
900
+ int detail, void *opaque)
901
+ {
902
+ return domain_event_lifecycle_callback(conn, dom, event, detail, opaque);
903
+ }
904
+ /*
905
+ * call-seq:
906
+ * conn.domain_event_register(callback, opaque=nil) -> nil
907
+ *
908
+ * Call virConnectDomainEventRegister[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectDomainEventRegister]
909
+ * to register callback for domain lifecycle events with libvirt. The
910
+ * callback can either be a Symbol (that is the name of a method to callback)
911
+ * or a Proc. The callback must accept 5 parameters: Libvirt::Connect,
912
+ * Libvirt::Domain, event, detail, opaque. The opaque parameter to
913
+ * domain_event_register can be any valid ruby type, and will be passed into
914
+ * callback as "opaque". This method is deprecated in favor of
915
+ * domain_event_register_any.
916
+ */
917
+ static VALUE libvirt_connect_domain_event_register(int argc, VALUE *argv,
918
+ VALUE c)
919
+ {
920
+ VALUE cb, opaque, passthrough;
921
+
922
+ rb_scan_args(argc, argv, "11", &cb, &opaque);
923
+
924
+ if (!ruby_libvirt_is_symbol_or_proc(cb)) {
925
+ rb_raise(rb_eTypeError,
926
+ "wrong argument type (expected Symbol or Proc)");
927
+ }
928
+
929
+ passthrough = rb_ary_new();
930
+ rb_ary_store(passthrough, 0, cb);
931
+ rb_ary_store(passthrough, 1, opaque);
932
+
933
+ ruby_libvirt_generate_call_nil(virConnectDomainEventRegister,
934
+ ruby_libvirt_connect_get(c),
935
+ ruby_libvirt_connect_get(c),
936
+ domain_event_callback, (void *)passthrough,
937
+ NULL);
938
+ }
939
+
940
+ /*
941
+ * call-seq:
942
+ * conn.domain_event_deregister(callback) -> nil
943
+ *
944
+ * Call virConnectDomainEventDeregister[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectDomainEventDeregister]
945
+ * to deregister the event callback from libvirt. This method is deprecated
946
+ * in favor of domain_event_deregister_any (though they cannot be mixed; if
947
+ * the callback was registered with domain_event_register, it must be
948
+ * deregistered with domain_event_deregister).
949
+ */
950
+ static VALUE libvirt_connect_domain_event_deregister(VALUE c)
951
+ {
952
+ ruby_libvirt_generate_call_nil(virConnectDomainEventDeregister,
953
+ ruby_libvirt_connect_get(c),
954
+ ruby_libvirt_connect_get(c),
955
+ domain_event_callback);
956
+ }
957
+ #endif
958
+
959
+ /*
960
+ * call-seq:
961
+ * conn.num_of_domains -> Fixnum
962
+ *
963
+ * Call virConnectNumOfDomains[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectNumOfDomains]
964
+ * to retrieve the number of active domains on this connection.
965
+ */
966
+ static VALUE libvirt_connect_num_of_domains(VALUE c)
967
+ {
968
+ gen_conn_num_of(c, Domains);
969
+ }
970
+
971
+ /*
972
+ * call-seq:
973
+ * conn.list_domains -> list
974
+ *
975
+ * Call virConnectListDomains[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectListDomains]
976
+ * to retrieve a list of active domain IDs on this connection.
977
+ */
978
+ static VALUE libvirt_connect_list_domains(VALUE c)
979
+ {
980
+ int i, r, num, *ids;
981
+ VALUE result;
982
+
983
+ num = virConnectNumOfDomains(ruby_libvirt_connect_get(c));
984
+ ruby_libvirt_raise_error_if(num < 0, e_RetrieveError,
985
+ "virConnectNumOfDomains",
986
+ ruby_libvirt_connect_get(c));
987
+
988
+ result = rb_ary_new2(num);
989
+
990
+ if (num == 0) {
991
+ return result;
992
+ }
993
+
994
+ ids = alloca(sizeof(int) * num);
995
+ r = virConnectListDomains(ruby_libvirt_connect_get(c), ids, num);
996
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError,
997
+ "virConnectListDomains",
998
+ ruby_libvirt_connect_get(c));
999
+
1000
+ for (i = 0; i < num; i++) {
1001
+ rb_ary_store(result, i, INT2NUM(ids[i]));
1002
+ }
1003
+
1004
+ return result;
1005
+ }
1006
+
1007
+ /*
1008
+ * call-seq:
1009
+ * conn.num_of_defined_domains -> Fixnum
1010
+ *
1011
+ * Call virConnectNumOfDefinedDomains[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectNumOfDefinedDomains]
1012
+ * to retrieve the number of inactive domains on this connection.
1013
+ */
1014
+ static VALUE libvirt_connect_num_of_defined_domains(VALUE c)
1015
+ {
1016
+ gen_conn_num_of(c, DefinedDomains);
1017
+ }
1018
+
1019
+ /*
1020
+ * call-seq:
1021
+ * conn.list_defined_domains -> list
1022
+ *
1023
+ * Call virConnectListDefinedDomains[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectListDefinedDomains]
1024
+ * to retrieve a list of inactive domain names on this connection.
1025
+ */
1026
+ static VALUE libvirt_connect_list_defined_domains(VALUE c)
1027
+ {
1028
+ gen_conn_list_names(c, DefinedDomains);
1029
+ }
1030
+
1031
+ /*
1032
+ * call-seq:
1033
+ * conn.create_domain_linux(xml, flags=0) -> Libvirt::Domain
1034
+ *
1035
+ * Call virDomainCreateLinux[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateLinux]
1036
+ * to start a transient domain from the given XML. Deprecated; use
1037
+ * conn.create_domain_xml instead.
1038
+ */
1039
+ static VALUE libvirt_connect_create_linux(int argc, VALUE *argv, VALUE c)
1040
+ {
1041
+ virDomainPtr dom;
1042
+ VALUE flags, xml;
1043
+
1044
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1045
+
1046
+ dom = virDomainCreateLinux(ruby_libvirt_connect_get(c),
1047
+ StringValueCStr(xml),
1048
+ ruby_libvirt_value_to_uint(flags));
1049
+ ruby_libvirt_raise_error_if(dom == NULL, e_Error, "virDomainCreateLinux",
1050
+ ruby_libvirt_connect_get(c));
1051
+
1052
+ return ruby_libvirt_domain_new(dom, c);
1053
+ }
1054
+
1055
+ #if HAVE_VIRDOMAINCREATEXML
1056
+ /*
1057
+ * call-seq:
1058
+ * conn.create_domain_xml(xml, flags=0) -> Libvirt::Domain
1059
+ *
1060
+ * Call virDomainCreateXML[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateXML]
1061
+ * to start a transient domain from the given XML.
1062
+ */
1063
+ static VALUE libvirt_connect_create_domain_xml(int argc, VALUE *argv, VALUE c)
1064
+ {
1065
+ virDomainPtr dom;
1066
+ VALUE flags, xml;
1067
+
1068
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1069
+
1070
+ dom = virDomainCreateXML(ruby_libvirt_connect_get(c), StringValueCStr(xml),
1071
+ ruby_libvirt_value_to_uint(flags));
1072
+ ruby_libvirt_raise_error_if(dom == NULL, e_Error, "virDomainCreateXML",
1073
+ ruby_libvirt_connect_get(c));
1074
+
1075
+ return ruby_libvirt_domain_new(dom, c);
1076
+ }
1077
+ #endif
1078
+
1079
+ /*
1080
+ * call-seq:
1081
+ * conn.lookup_domain_by_name(name) -> Libvirt::Domain
1082
+ *
1083
+ * Call virDomainLookupByName[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainLookupByName]
1084
+ * to retrieve a domain object for name.
1085
+ */
1086
+ static VALUE libvirt_connect_lookup_domain_by_name(VALUE c, VALUE name)
1087
+ {
1088
+ virDomainPtr dom;
1089
+
1090
+ dom = virDomainLookupByName(ruby_libvirt_connect_get(c),
1091
+ StringValueCStr(name));
1092
+ ruby_libvirt_raise_error_if(dom == NULL, e_RetrieveError,
1093
+ "virDomainLookupByName",
1094
+ ruby_libvirt_connect_get(c));
1095
+
1096
+ return ruby_libvirt_domain_new(dom, c);
1097
+ }
1098
+
1099
+ /*
1100
+ * call-seq:
1101
+ * conn.lookup_domain_by_id(id) -> Libvirt::Domain
1102
+ *
1103
+ * Call virDomainLookupByID[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainLookupByID]
1104
+ * to retrieve a domain object for id.
1105
+ */
1106
+ static VALUE libvirt_connect_lookup_domain_by_id(VALUE c, VALUE id)
1107
+ {
1108
+ virDomainPtr dom;
1109
+
1110
+ dom = virDomainLookupByID(ruby_libvirt_connect_get(c), NUM2INT(id));
1111
+ ruby_libvirt_raise_error_if(dom == NULL, e_RetrieveError,
1112
+ "virDomainLookupByID",
1113
+ ruby_libvirt_connect_get(c));
1114
+
1115
+ return ruby_libvirt_domain_new(dom, c);
1116
+ }
1117
+
1118
+ /*
1119
+ * call-seq:
1120
+ * conn.lookup_domain_by_uuid(uuid) -> Libvirt::Domain
1121
+ *
1122
+ * Call virDomainLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainLookupByUUIDString]
1123
+ * to retrieve a domain object for uuid.
1124
+ */
1125
+ static VALUE libvirt_connect_lookup_domain_by_uuid(VALUE c, VALUE uuid)
1126
+ {
1127
+ virDomainPtr dom;
1128
+
1129
+ dom = virDomainLookupByUUIDString(ruby_libvirt_connect_get(c),
1130
+ StringValueCStr(uuid));
1131
+ ruby_libvirt_raise_error_if(dom == NULL, e_RetrieveError,
1132
+ "virDomainLookupByUUID",
1133
+ ruby_libvirt_connect_get(c));
1134
+
1135
+ return ruby_libvirt_domain_new(dom, c);
1136
+ }
1137
+
1138
+ /*
1139
+ * call-seq:
1140
+ * conn.define_domain_xml(xml, flags=0) -> Libvirt::Domain
1141
+ *
1142
+ * Call virDomainDefineXML[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainDefineXML]
1143
+ * to define a permanent domain on this connection.
1144
+ */
1145
+ static VALUE libvirt_connect_define_domain_xml(int argc, VALUE *argv, VALUE c)
1146
+ {
1147
+ virDomainPtr dom;
1148
+ VALUE xml;
1149
+ VALUE flags;
1150
+
1151
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1152
+
1153
+ #if HAVE_VIRDOMAINDEFINEXMLFLAGS
1154
+ dom = virDomainDefineXMLFlags(ruby_libvirt_connect_get(c),
1155
+ StringValueCStr(xml),
1156
+ ruby_libvirt_value_to_uint(flags));
1157
+ #else
1158
+ if (ruby_libvirt_value_to_uint(flags) != 0) {
1159
+ rb_raise(e_NoSupportError, "Non-zero flags not supported");
1160
+ }
1161
+ dom = virDomainDefineXML(ruby_libvirt_connect_get(c), StringValueCStr(xml));
1162
+ #endif
1163
+
1164
+ ruby_libvirt_raise_error_if(dom == NULL, e_DefinitionError,
1165
+ "virDomainDefineXML",
1166
+ ruby_libvirt_connect_get(c));
1167
+
1168
+ return ruby_libvirt_domain_new(dom, c);
1169
+ }
1170
+
1171
+ #if HAVE_VIRCONNECTDOMAINXMLFROMNATIVE
1172
+ /*
1173
+ * call-seq:
1174
+ * conn.domain_xml_from_native(nativeFormat, xml, flags=0) -> String
1175
+ *
1176
+ * Call virConnectDomainXMLFromNative[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectDomainXMLFromNative]
1177
+ * to convert a native hypervisor domain representation to libvirt XML.
1178
+ */
1179
+ static VALUE libvirt_connect_domain_xml_from_native(int argc, VALUE *argv,
1180
+ VALUE c)
1181
+ {
1182
+ VALUE nativeFormat, xml, flags;
1183
+
1184
+ rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);
1185
+
1186
+ ruby_libvirt_generate_call_string(virConnectDomainXMLFromNative,
1187
+ ruby_libvirt_connect_get(c), 1,
1188
+ ruby_libvirt_connect_get(c),
1189
+ StringValueCStr(nativeFormat),
1190
+ StringValueCStr(xml),
1191
+ ruby_libvirt_value_to_uint(flags));
1192
+ }
1193
+ #endif
1194
+
1195
+ #if HAVE_VIRCONNECTDOMAINXMLTONATIVE
1196
+ /*
1197
+ * call-seq:
1198
+ * conn.domain_xml_to_native(nativeFormat, xml, flags=0) -> String
1199
+ *
1200
+ * Call virConnectDomainXMLToNative[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectDomainXMLToNative]
1201
+ * to convert libvirt XML to a native domain hypervisor representation.
1202
+ */
1203
+ static VALUE libvirt_connect_domain_xml_to_native(int argc, VALUE *argv,
1204
+ VALUE c)
1205
+ {
1206
+ VALUE nativeFormat, xml, flags;
1207
+
1208
+ rb_scan_args(argc, argv, "21", &nativeFormat, &xml, &flags);
1209
+
1210
+ ruby_libvirt_generate_call_string(virConnectDomainXMLToNative,
1211
+ ruby_libvirt_connect_get(c), 1,
1212
+ ruby_libvirt_connect_get(c),
1213
+ StringValueCStr(nativeFormat),
1214
+ StringValueCStr(xml),
1215
+ ruby_libvirt_value_to_uint(flags));
1216
+ }
1217
+ #endif
1218
+
1219
+ #if HAVE_TYPE_VIRINTERFACEPTR
1220
+ /*
1221
+ * call-seq:
1222
+ * conn.num_of_interfaces -> Fixnum
1223
+ *
1224
+ * Call virConnectNumOfInterfaces[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virConnectNumOfInterfaces]
1225
+ * to retrieve the number of active interfaces on this connection.
1226
+ */
1227
+ static VALUE libvirt_connect_num_of_interfaces(VALUE c)
1228
+ {
1229
+ gen_conn_num_of(c, Interfaces);
1230
+ }
1231
+
1232
+ /*
1233
+ * call-seq:
1234
+ * conn.list_interfaces -> list
1235
+ *
1236
+ * Call virConnectListInterfaces[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virConnectListInterfaces]
1237
+ * to retrieve a list of active interface names on this connection.
1238
+ */
1239
+ static VALUE libvirt_connect_list_interfaces(VALUE c)
1240
+ {
1241
+ gen_conn_list_names(c, Interfaces);
1242
+ }
1243
+
1244
+ /*
1245
+ * call-seq:
1246
+ * conn.num_of_defined_interfaces -> Fixnum
1247
+ *
1248
+ * Call virConnectNumOfDefinedInterfaces[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virConnectNumOfDefinedInterfaces]
1249
+ * to retrieve the number of inactive interfaces on this connection.
1250
+ */
1251
+ static VALUE libvirt_connect_num_of_defined_interfaces(VALUE c)
1252
+ {
1253
+ gen_conn_num_of(c, DefinedInterfaces);
1254
+ }
1255
+
1256
+ /*
1257
+ * call-seq:
1258
+ * conn.list_defined_interfaces -> list
1259
+ *
1260
+ * Call virConnectListDefinedInterfaces[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virConnectListDefinedInterfaces]
1261
+ * to retrieve a list of inactive interface names on this connection.
1262
+ */
1263
+ static VALUE libvirt_connect_list_defined_interfaces(VALUE c)
1264
+ {
1265
+ gen_conn_list_names(c, DefinedInterfaces);
1266
+ }
1267
+
1268
+ /*
1269
+ * call-seq:
1270
+ * conn.lookup_interface_by_name(name) -> Libvirt::Interface
1271
+ *
1272
+ * Call virInterfaceLookupByName[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceLookupByName]
1273
+ * to retrieve an interface object by name.
1274
+ */
1275
+ static VALUE libvirt_connect_lookup_interface_by_name(VALUE c, VALUE name)
1276
+ {
1277
+ virInterfacePtr iface;
1278
+
1279
+ iface = virInterfaceLookupByName(ruby_libvirt_connect_get(c),
1280
+ StringValueCStr(name));
1281
+ ruby_libvirt_raise_error_if(iface == NULL, e_RetrieveError,
1282
+ "virInterfaceLookupByName",
1283
+ ruby_libvirt_connect_get(c));
1284
+
1285
+ return ruby_libvirt_interface_new(iface, c);
1286
+ }
1287
+
1288
+ /*
1289
+ * call-seq:
1290
+ * conn.lookup_interface_by_mac(mac) -> Libvirt::Interface
1291
+ *
1292
+ * Call virInterfaceLookupByMACString[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceLookupByMACString]
1293
+ * to retrieve an interface object by MAC address.
1294
+ */
1295
+ static VALUE libvirt_connect_lookup_interface_by_mac(VALUE c, VALUE mac)
1296
+ {
1297
+ virInterfacePtr iface;
1298
+
1299
+ iface = virInterfaceLookupByMACString(ruby_libvirt_connect_get(c),
1300
+ StringValueCStr(mac));
1301
+ ruby_libvirt_raise_error_if(iface == NULL, e_RetrieveError,
1302
+ "virInterfaceLookupByMACString",
1303
+ ruby_libvirt_connect_get(c));
1304
+
1305
+ return ruby_libvirt_interface_new(iface, c);
1306
+ }
1307
+
1308
+ /*
1309
+ * call-seq:
1310
+ * conn.define_interface_xml(xml, flags=0) -> Libvirt::Interface
1311
+ *
1312
+ * Call virInterfaceDefineXML[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceDefineXML]
1313
+ * to define a new interface from xml.
1314
+ */
1315
+ static VALUE libvirt_connect_define_interface_xml(int argc, VALUE *argv,
1316
+ VALUE c)
1317
+ {
1318
+ virInterfacePtr iface;
1319
+ VALUE xml, flags;
1320
+
1321
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1322
+
1323
+ iface = virInterfaceDefineXML(ruby_libvirt_connect_get(c),
1324
+ StringValueCStr(xml),
1325
+ ruby_libvirt_value_to_uint(flags));
1326
+ ruby_libvirt_raise_error_if(iface == NULL, e_DefinitionError,
1327
+ "virInterfaceDefineXML",
1328
+ ruby_libvirt_connect_get(c));
1329
+
1330
+ return ruby_libvirt_interface_new(iface, c);
1331
+ }
1332
+ #endif
1333
+
1334
+ /*
1335
+ * call-seq:
1336
+ * conn.num_of_networks -> Fixnum
1337
+ *
1338
+ * Call virConnectNumOfNetworks[http://www.libvirt.org/html/libvirt-libvirt-network.html#virConnectNumOfNetworks]
1339
+ * to retrieve the number of active networks on this connection.
1340
+ */
1341
+ static VALUE libvirt_connect_num_of_networks(VALUE c)
1342
+ {
1343
+ gen_conn_num_of(c, Networks);
1344
+ }
1345
+
1346
+ /*
1347
+ * call-seq:
1348
+ * conn.list_networks -> list
1349
+ *
1350
+ * Call virConnectListNetworks[http://www.libvirt.org/html/libvirt-libvirt-network.html#virConnectListNetworks]
1351
+ * to retrieve a list of active network names on this connection.
1352
+ */
1353
+ static VALUE libvirt_connect_list_networks(VALUE c)
1354
+ {
1355
+ gen_conn_list_names(c, Networks);
1356
+ }
1357
+
1358
+ /*
1359
+ * call-seq:
1360
+ * conn.num_of_defined_networks -> Fixnum
1361
+ *
1362
+ * Call virConnectNumOfDefinedNetworks[http://www.libvirt.org/html/libvirt-libvirt-network.html#virConnectNumOfDefinedNetworks]
1363
+ * to retrieve the number of inactive networks on this connection.
1364
+ */
1365
+ static VALUE libvirt_connect_num_of_defined_networks(VALUE c)
1366
+ {
1367
+ gen_conn_num_of(c, DefinedNetworks);
1368
+ }
1369
+
1370
+ /*
1371
+ * call-seq:
1372
+ * conn.list_of_defined_networks -> list
1373
+ *
1374
+ * Call virConnectListDefinedNetworks[http://www.libvirt.org/html/libvirt-libvirt-network.html#virConnectListDefinedNetworks]
1375
+ * to retrieve a list of inactive network names on this connection.
1376
+ */
1377
+ static VALUE libvirt_connect_list_defined_networks(VALUE c)
1378
+ {
1379
+ gen_conn_list_names(c, DefinedNetworks);
1380
+ }
1381
+
1382
+ /*
1383
+ * call-seq:
1384
+ * conn.lookup_network_by_name(name) -> Libvirt::Network
1385
+ *
1386
+ * Call virNetworkLookupByName[http://www.libvirt.org/html/libvirt-libvirt-network.html#virNetworkLookupByName]
1387
+ * to retrieve a network object by name.
1388
+ */
1389
+ static VALUE libvirt_connect_lookup_network_by_name(VALUE c, VALUE name)
1390
+ {
1391
+ virNetworkPtr netw;
1392
+
1393
+ netw = virNetworkLookupByName(ruby_libvirt_connect_get(c),
1394
+ StringValueCStr(name));
1395
+ ruby_libvirt_raise_error_if(netw == NULL, e_RetrieveError,
1396
+ "virNetworkLookupByName",
1397
+ ruby_libvirt_connect_get(c));
1398
+
1399
+ return ruby_libvirt_network_new(netw, c);
1400
+ }
1401
+
1402
+ /*
1403
+ * call-seq:
1404
+ * conn.lookup_network_by_uuid(uuid) -> Libvirt::Network
1405
+ *
1406
+ * Call virNetworkLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt-network.html#virNetworkLookupByUUIDString]
1407
+ * to retrieve a network object by UUID.
1408
+ */
1409
+ static VALUE libvirt_connect_lookup_network_by_uuid(VALUE c, VALUE uuid)
1410
+ {
1411
+ virNetworkPtr netw;
1412
+
1413
+ netw = virNetworkLookupByUUIDString(ruby_libvirt_connect_get(c),
1414
+ StringValueCStr(uuid));
1415
+ ruby_libvirt_raise_error_if(netw == NULL, e_RetrieveError,
1416
+ "virNetworkLookupByUUID",
1417
+ ruby_libvirt_connect_get(c));
1418
+
1419
+ return ruby_libvirt_network_new(netw, c);
1420
+ }
1421
+
1422
+ /*
1423
+ * call-seq:
1424
+ * conn.create_network_xml(xml) -> Libvirt::Network
1425
+ *
1426
+ * Call virNetworkCreateXML[http://www.libvirt.org/html/libvirt-libvirt-network.html#virNetworkCreateXML]
1427
+ * to start a new transient network from xml.
1428
+ */
1429
+ static VALUE libvirt_connect_create_network_xml(VALUE c, VALUE xml)
1430
+ {
1431
+ virNetworkPtr netw;
1432
+
1433
+ netw = virNetworkCreateXML(ruby_libvirt_connect_get(c),
1434
+ StringValueCStr(xml));
1435
+ ruby_libvirt_raise_error_if(netw == NULL, e_Error, "virNetworkCreateXML",
1436
+ ruby_libvirt_connect_get(c));
1437
+
1438
+ return ruby_libvirt_network_new(netw, c);
1439
+ }
1440
+
1441
+ /*
1442
+ * call-seq:
1443
+ * conn.define_network_xml(xml) -> Libvirt::Network
1444
+ *
1445
+ * Call virNetworkDefineXML[http://www.libvirt.org/html/libvirt-libvirt-network.html#virNetworkDefineXML]
1446
+ * to define a new permanent network from xml.
1447
+ */
1448
+ static VALUE libvirt_connect_define_network_xml(VALUE c, VALUE xml)
1449
+ {
1450
+ virNetworkPtr netw;
1451
+
1452
+ netw = virNetworkDefineXML(ruby_libvirt_connect_get(c),
1453
+ StringValueCStr(xml));
1454
+ ruby_libvirt_raise_error_if(netw == NULL, e_DefinitionError,
1455
+ "virNetworkDefineXML",
1456
+ ruby_libvirt_connect_get(c));
1457
+
1458
+ return ruby_libvirt_network_new(netw, c);
1459
+ }
1460
+
1461
+ #if HAVE_TYPE_VIRNODEDEVICEPTR
1462
+
1463
+ /*
1464
+ * call-seq:
1465
+ * conn.num_of_nodedevices(cap=nil, flags=0) -> Fixnum
1466
+ *
1467
+ * Call virNodeNumOfDevices[http://www.libvirt.org/html/libvirt-libvirt-nodedev.html#virNodeNumOfDevices]
1468
+ * to retrieve the number of node devices on this connection.
1469
+ */
1470
+ static VALUE libvirt_connect_num_of_nodedevices(int argc, VALUE *argv, VALUE c)
1471
+ {
1472
+ int result;
1473
+ VALUE cap, flags;
1474
+
1475
+ rb_scan_args(argc, argv, "02", &cap, &flags);
1476
+
1477
+ result = virNodeNumOfDevices(ruby_libvirt_connect_get(c),
1478
+ ruby_libvirt_get_cstring_or_null(cap),
1479
+ ruby_libvirt_value_to_uint(flags));
1480
+ ruby_libvirt_raise_error_if(result < 0, e_RetrieveError,
1481
+ "virNodeNumOfDevices",
1482
+ ruby_libvirt_connect_get(c));
1483
+
1484
+ return INT2NUM(result);
1485
+ }
1486
+
1487
+ /*
1488
+ * call-seq:
1489
+ * conn.list_nodedevices(cap=nil, flags=0) -> list
1490
+ *
1491
+ * Call virNodeListDevices[http://www.libvirt.org/html/libvirt-libvirt-nodedev.html#virNodeListDevices]
1492
+ * to retrieve a list of node device names on this connection.
1493
+ */
1494
+ static VALUE libvirt_connect_list_nodedevices(int argc, VALUE *argv, VALUE c)
1495
+ {
1496
+ int r, num;
1497
+ VALUE cap, flags;
1498
+ char *capstr;
1499
+ char **names;
1500
+
1501
+ rb_scan_args(argc, argv, "02", &cap, &flags);
1502
+
1503
+ if (TYPE(flags) != T_NIL && TYPE(flags) != T_FIXNUM) {
1504
+ rb_raise(rb_eTypeError,
1505
+ "wrong argument type (expected Number)");
1506
+ }
1507
+
1508
+ capstr = ruby_libvirt_get_cstring_or_null(cap);
1509
+
1510
+ num = virNodeNumOfDevices(ruby_libvirt_connect_get(c), capstr, 0);
1511
+ ruby_libvirt_raise_error_if(num < 0, e_RetrieveError,
1512
+ "virNodeNumOfDevices",
1513
+ ruby_libvirt_connect_get(c));
1514
+ if (num == 0) {
1515
+ /* if num is 0, don't call virNodeListDevices function */
1516
+ return rb_ary_new2(num);
1517
+ }
1518
+
1519
+ names = alloca(sizeof(char *) * num);
1520
+ r = virNodeListDevices(ruby_libvirt_connect_get(c), capstr, names, num,
1521
+ ruby_libvirt_value_to_uint(flags));
1522
+ ruby_libvirt_raise_error_if(r < 0, e_RetrieveError, "virNodeListDevices",
1523
+ ruby_libvirt_connect_get(c));
1524
+
1525
+ return ruby_libvirt_generate_list(r, names);
1526
+ }
1527
+
1528
+ /*
1529
+ * call-seq:
1530
+ * conn.lookup_nodedevice_by_name(name) -> Libvirt::NodeDevice
1531
+ *
1532
+ * Call virNodeDeviceLookupByName[http://www.libvirt.org/html/libvirt-libvirt-nodedev.html#virNodeDeviceLookupByName]
1533
+ * to retrieve a nodedevice object by name.
1534
+ */
1535
+ static VALUE libvirt_connect_lookup_nodedevice_by_name(VALUE c, VALUE name)
1536
+ {
1537
+ virNodeDevicePtr nodedev;
1538
+
1539
+ nodedev = virNodeDeviceLookupByName(ruby_libvirt_connect_get(c),
1540
+ StringValueCStr(name));
1541
+ ruby_libvirt_raise_error_if(nodedev == NULL, e_RetrieveError,
1542
+ "virNodeDeviceLookupByName",
1543
+ ruby_libvirt_connect_get(c));
1544
+
1545
+ return ruby_libvirt_nodedevice_new(nodedev, c);
1546
+
1547
+ }
1548
+
1549
+ #if HAVE_VIRNODEDEVICECREATEXML
1550
+ /*
1551
+ * call-seq:
1552
+ * conn.create_nodedevice_xml(xml, flags=0) -> Libvirt::NodeDevice
1553
+ *
1554
+ * Call virNodeDeviceCreateXML[http://www.libvirt.org/html/libvirt-libvirt-nodedev.html#virNodeDeviceCreateXML]
1555
+ * to create a new node device from xml.
1556
+ */
1557
+ static VALUE libvirt_connect_create_nodedevice_xml(int argc, VALUE *argv,
1558
+ VALUE c)
1559
+ {
1560
+ virNodeDevicePtr nodedev;
1561
+ VALUE xml, flags;
1562
+
1563
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1564
+
1565
+ nodedev = virNodeDeviceCreateXML(ruby_libvirt_connect_get(c),
1566
+ StringValueCStr(xml),
1567
+ ruby_libvirt_value_to_uint(flags));
1568
+ ruby_libvirt_raise_error_if(nodedev == NULL, e_Error,
1569
+ "virNodeDeviceCreateXML",
1570
+ ruby_libvirt_connect_get(c));
1571
+
1572
+ return ruby_libvirt_nodedevice_new(nodedev, c);
1573
+ }
1574
+ #endif
1575
+ #endif
1576
+
1577
+ #if HAVE_TYPE_VIRNWFILTERPTR
1578
+
1579
+ /*
1580
+ * call-seq:
1581
+ * conn.num_of_nwfilters -> Fixnum
1582
+ *
1583
+ * Call virConnectNumOfNWFilters[http://www.libvirt.org/html/libvirt-libvirt-nwfilter.html#virConnectNumOfNWFilters]
1584
+ * to retrieve the number of network filters on this connection.
1585
+ */
1586
+ static VALUE libvirt_connect_num_of_nwfilters(VALUE c)
1587
+ {
1588
+ gen_conn_num_of(c, NWFilters);
1589
+ }
1590
+
1591
+ /*
1592
+ * call-seq:
1593
+ * conn.list_nwfilters -> list
1594
+ *
1595
+ * Call virConnectListNWFilters[http://www.libvirt.org/html/libvirt-libvirt-nwfilter.html#virConnectListNWFilters]
1596
+ * to retrieve a list of network filter names on this connection.
1597
+ */
1598
+ static VALUE libvirt_connect_list_nwfilters(VALUE c)
1599
+ {
1600
+ gen_conn_list_names(c, NWFilters);
1601
+ }
1602
+
1603
+ /*
1604
+ * call-seq:
1605
+ * conn.lookup_nwfilter_by_name(name) -> Libvirt::NWFilter
1606
+ *
1607
+ * Call virNWFilterLookupByName[http://www.libvirt.org/html/libvirt-libvirt-nwfilter.html#virNWFilterLookupByName]
1608
+ * to retrieve a network filter object by name.
1609
+ */
1610
+ static VALUE libvirt_connect_lookup_nwfilter_by_name(VALUE c, VALUE name)
1611
+ {
1612
+ virNWFilterPtr nwfilter;
1613
+
1614
+ nwfilter = virNWFilterLookupByName(ruby_libvirt_connect_get(c),
1615
+ StringValueCStr(name));
1616
+ ruby_libvirt_raise_error_if(nwfilter == NULL, e_RetrieveError,
1617
+ "virNWFilterLookupByName",
1618
+ ruby_libvirt_connect_get(c));
1619
+
1620
+ return ruby_libvirt_nwfilter_new(nwfilter, c);
1621
+ }
1622
+
1623
+ /*
1624
+ * call-seq:
1625
+ * conn.lookup_nwfilter_by_uuid(uuid) -> Libvirt::NWFilter
1626
+ *
1627
+ * Call virNWFilterLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt-nwfilter.html#virNWFilterLookupByUUIDString]
1628
+ * to retrieve a network filter object by UUID.
1629
+ */
1630
+ static VALUE libvirt_connect_lookup_nwfilter_by_uuid(VALUE c, VALUE uuid)
1631
+ {
1632
+ virNWFilterPtr nwfilter;
1633
+
1634
+ nwfilter = virNWFilterLookupByUUIDString(ruby_libvirt_connect_get(c),
1635
+ StringValueCStr(uuid));
1636
+ ruby_libvirt_raise_error_if(nwfilter == NULL, e_RetrieveError,
1637
+ "virNWFilterLookupByUUIDString",
1638
+ ruby_libvirt_connect_get(c));
1639
+
1640
+ return ruby_libvirt_nwfilter_new(nwfilter, c);
1641
+ }
1642
+
1643
+ /*
1644
+ * call-seq:
1645
+ * conn.define_nwfilter_xml(xml) -> Libvirt::NWFilter
1646
+ *
1647
+ * Call virNWFilterDefineXML[http://www.libvirt.org/html/libvirt-libvirt-nwfilter.html#virNWFilterDefineXML]
1648
+ * to define a new network filter from xml.
1649
+ */
1650
+ static VALUE libvirt_connect_define_nwfilter_xml(VALUE c, VALUE xml)
1651
+ {
1652
+ virNWFilterPtr nwfilter;
1653
+
1654
+ nwfilter = virNWFilterDefineXML(ruby_libvirt_connect_get(c),
1655
+ StringValueCStr(xml));
1656
+ ruby_libvirt_raise_error_if(nwfilter == NULL, e_DefinitionError,
1657
+ "virNWFilterDefineXML",
1658
+ ruby_libvirt_connect_get(c));
1659
+
1660
+ return ruby_libvirt_nwfilter_new(nwfilter, c);
1661
+ }
1662
+ #endif
1663
+
1664
+ #if HAVE_TYPE_VIRSECRETPTR
1665
+
1666
+ /*
1667
+ * call-seq:
1668
+ * conn.num_of_secrets -> Fixnum
1669
+ *
1670
+ * Call virConnectNumOfSecrets[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virConnectNumOfSecrets]
1671
+ * to retrieve the number of secrets on this connection.
1672
+ */
1673
+ static VALUE libvirt_connect_num_of_secrets(VALUE c)
1674
+ {
1675
+ gen_conn_num_of(c, Secrets);
1676
+ }
1677
+
1678
+ /*
1679
+ * call-seq:
1680
+ * conn.list_secrets -> list
1681
+ *
1682
+ * Call virConnectListSecrets[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virConnectListSecrets]
1683
+ * to retrieve a list of secret UUIDs on this connection.
1684
+ */
1685
+ static VALUE libvirt_connect_list_secrets(VALUE c)
1686
+ {
1687
+ gen_conn_list_names(c, Secrets);
1688
+ }
1689
+
1690
+ /*
1691
+ * call-seq:
1692
+ * conn.lookup_secret_by_uuid(uuid) -> Libvirt::Secret
1693
+ *
1694
+ * Call virSecretLookupByUUID[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretLookupByUUID]
1695
+ * to retrieve a network object from uuid.
1696
+ */
1697
+ static VALUE libvirt_connect_lookup_secret_by_uuid(VALUE c, VALUE uuid)
1698
+ {
1699
+ virSecretPtr secret;
1700
+
1701
+ secret = virSecretLookupByUUIDString(ruby_libvirt_connect_get(c),
1702
+ StringValueCStr(uuid));
1703
+ ruby_libvirt_raise_error_if(secret == NULL, e_RetrieveError,
1704
+ "virSecretLookupByUUID",
1705
+ ruby_libvirt_connect_get(c));
1706
+
1707
+ return ruby_libvirt_secret_new(secret, c);
1708
+ }
1709
+
1710
+ /*
1711
+ * call-seq:
1712
+ * conn.lookup_secret_by_usage(usagetype, usageID) -> Libvirt::Secret
1713
+ *
1714
+ * Call virSecretLookupByUsage[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretLookupByUsage]
1715
+ * to retrieve a secret by usagetype.
1716
+ */
1717
+ static VALUE libvirt_connect_lookup_secret_by_usage(VALUE c, VALUE usagetype,
1718
+ VALUE usageID)
1719
+ {
1720
+ virSecretPtr secret;
1721
+
1722
+ secret = virSecretLookupByUsage(ruby_libvirt_connect_get(c),
1723
+ NUM2UINT(usagetype),
1724
+ StringValueCStr(usageID));
1725
+ ruby_libvirt_raise_error_if(secret == NULL, e_RetrieveError,
1726
+ "virSecretLookupByUsage",
1727
+ ruby_libvirt_connect_get(c));
1728
+
1729
+ return ruby_libvirt_secret_new(secret, c);
1730
+ }
1731
+
1732
+ /*
1733
+ * call-seq:
1734
+ * conn.define_secret_xml(xml, flags=0) -> Libvirt::Secret
1735
+ *
1736
+ * Call virSecretDefineXML[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virSecretDefineXML]
1737
+ * to define a new secret from xml.
1738
+ */
1739
+ static VALUE libvirt_connect_define_secret_xml(int argc, VALUE *argv, VALUE c)
1740
+ {
1741
+ virSecretPtr secret;
1742
+ VALUE xml, flags;
1743
+
1744
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1745
+
1746
+ secret = virSecretDefineXML(ruby_libvirt_connect_get(c),
1747
+ StringValueCStr(xml),
1748
+ ruby_libvirt_value_to_uint(flags));
1749
+ ruby_libvirt_raise_error_if(secret == NULL, e_DefinitionError,
1750
+ "virSecretDefineXML",
1751
+ ruby_libvirt_connect_get(c));
1752
+
1753
+ return ruby_libvirt_secret_new(secret, c);
1754
+ }
1755
+ #endif
1756
+
1757
+ #if HAVE_TYPE_VIRSTORAGEPOOLPTR
1758
+
1759
+ VALUE pool_new(virStoragePoolPtr n, VALUE conn);
1760
+
1761
+ /*
1762
+ * call-seq:
1763
+ * conn.list_storage_pools -> list
1764
+ *
1765
+ * Call virConnectListStoragePools[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virConnectListStoragePools]
1766
+ * to retrieve a list of active storage pool names on this connection.
1767
+ */
1768
+ static VALUE libvirt_connect_list_storage_pools(VALUE c)
1769
+ {
1770
+ gen_conn_list_names(c, StoragePools);
1771
+ }
1772
+
1773
+ /*
1774
+ * call-seq:
1775
+ * conn.num_of_storage_pools -> Fixnum
1776
+ *
1777
+ * Call virConnectNumOfStoragePools[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virConnectNumOfStoragePools]
1778
+ * to retrieve the number of active storage pools on this connection.
1779
+ */
1780
+ static VALUE libvirt_connect_num_of_storage_pools(VALUE c)
1781
+ {
1782
+ gen_conn_num_of(c, StoragePools);
1783
+ }
1784
+
1785
+ /*
1786
+ * call-seq:
1787
+ * conn.list_defined_storage_pools -> list
1788
+ *
1789
+ * Call virConnectListDefinedStoragePools[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virConnectListDefinedStoragePools]
1790
+ * to retrieve a list of inactive storage pool names on this connection.
1791
+ */
1792
+ static VALUE libvirt_connect_list_defined_storage_pools(VALUE c)
1793
+ {
1794
+ gen_conn_list_names(c, DefinedStoragePools);
1795
+ }
1796
+
1797
+ /*
1798
+ * call-seq:
1799
+ * conn.num_of_defined_storage_pools -> Fixnum
1800
+ *
1801
+ * Call virConnectNumOfDefinedStoragePools[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virConnectNumOfDefinedStoragePools]
1802
+ * to retrieve the number of inactive storage pools on this connection.
1803
+ */
1804
+ static VALUE libvirt_connect_num_of_defined_storage_pools(VALUE c)
1805
+ {
1806
+ gen_conn_num_of(c, DefinedStoragePools);
1807
+ }
1808
+
1809
+ /*
1810
+ * call-seq:
1811
+ * conn.lookup_storage_pool_by_name(name) -> Libvirt::StoragePool
1812
+ *
1813
+ * Call virStoragePoolLookupByName[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolLookupByName]
1814
+ * to retrieve a storage pool object by name.
1815
+ */
1816
+ static VALUE libvirt_connect_lookup_pool_by_name(VALUE c, VALUE name)
1817
+ {
1818
+ virStoragePoolPtr pool;
1819
+
1820
+ pool = virStoragePoolLookupByName(ruby_libvirt_connect_get(c),
1821
+ StringValueCStr(name));
1822
+ ruby_libvirt_raise_error_if(pool == NULL, e_RetrieveError,
1823
+ "virStoragePoolLookupByName",
1824
+ ruby_libvirt_connect_get(c));
1825
+
1826
+ return pool_new(pool, c);
1827
+ }
1828
+
1829
+ /*
1830
+ * call-seq:
1831
+ * conn.lookup_storage_pool_by_uuid(uuid) -> Libvirt::StoragePool
1832
+ *
1833
+ * Call virStoragePoolLookupByUUIDString[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolLookupByUUIDString]
1834
+ * to retrieve a storage pool object by uuid.
1835
+ */
1836
+ static VALUE libvirt_connect_lookup_pool_by_uuid(VALUE c, VALUE uuid)
1837
+ {
1838
+ virStoragePoolPtr pool;
1839
+
1840
+ pool = virStoragePoolLookupByUUIDString(ruby_libvirt_connect_get(c),
1841
+ StringValueCStr(uuid));
1842
+ ruby_libvirt_raise_error_if(pool == NULL, e_RetrieveError,
1843
+ "virStoragePoolLookupByUUID",
1844
+ ruby_libvirt_connect_get(c));
1845
+
1846
+ return pool_new(pool, c);
1847
+ }
1848
+
1849
+ /*
1850
+ * call-seq:
1851
+ * conn.create_storage_pool_xml(xml, flags=0) -> Libvirt::StoragePool
1852
+ *
1853
+ * Call virStoragePoolCreateXML[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolCreateXML]
1854
+ * to start a new transient storage pool from xml.
1855
+ */
1856
+ static VALUE libvirt_connect_create_pool_xml(int argc, VALUE *argv, VALUE c)
1857
+ {
1858
+ virStoragePoolPtr pool;
1859
+ VALUE xml, flags;
1860
+
1861
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1862
+
1863
+ pool = virStoragePoolCreateXML(ruby_libvirt_connect_get(c),
1864
+ StringValueCStr(xml),
1865
+ ruby_libvirt_value_to_uint(flags));
1866
+ ruby_libvirt_raise_error_if(pool == NULL, e_Error,
1867
+ "virStoragePoolCreateXML",
1868
+ ruby_libvirt_connect_get(c));
1869
+
1870
+ return pool_new(pool, c);
1871
+ }
1872
+
1873
+ /*
1874
+ * call-seq:
1875
+ * conn.define_storage_pool_xml(xml, flags=0) -> Libvirt::StoragePool
1876
+ *
1877
+ * Call virStoragePoolDefineXML[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virStoragePoolDefineXML]
1878
+ * to define a permanent storage pool from xml.
1879
+ */
1880
+ static VALUE libvirt_connect_define_pool_xml(int argc, VALUE *argv, VALUE c)
1881
+ {
1882
+ virStoragePoolPtr pool;
1883
+ VALUE xml, flags;
1884
+
1885
+ rb_scan_args(argc, argv, "11", &xml, &flags);
1886
+
1887
+ pool = virStoragePoolDefineXML(ruby_libvirt_connect_get(c),
1888
+ StringValueCStr(xml),
1889
+ ruby_libvirt_value_to_uint(flags));
1890
+ ruby_libvirt_raise_error_if(pool == NULL, e_DefinitionError,
1891
+ "virStoragePoolDefineXML",
1892
+ ruby_libvirt_connect_get(c));
1893
+
1894
+ return pool_new(pool, c);
1895
+ }
1896
+
1897
+ /*
1898
+ * call-seq:
1899
+ * conn.discover_storage_pool_sources(type, srcSpec=nil, flags=0) -> String
1900
+ *
1901
+ * Call virConnectFindStoragePoolSources[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virConnectFindStoragePoolSources]
1902
+ * to find the storage pool sources corresponding to type.
1903
+ */
1904
+ static VALUE libvirt_connect_find_storage_pool_sources(int argc, VALUE *argv,
1905
+ VALUE c)
1906
+ {
1907
+ VALUE type, srcSpec, flags;
1908
+
1909
+ rb_scan_args(argc, argv, "12", &type, &srcSpec, &flags);
1910
+
1911
+ ruby_libvirt_generate_call_string(virConnectFindStoragePoolSources,
1912
+ ruby_libvirt_connect_get(c), 1,
1913
+ ruby_libvirt_connect_get(c),
1914
+ StringValueCStr(type),
1915
+ ruby_libvirt_get_cstring_or_null(srcSpec),
1916
+ ruby_libvirt_value_to_uint(flags));
1917
+ }
1918
+ #endif
1919
+
1920
+ #if HAVE_VIRCONNECTGETSYSINFO
1921
+ /*
1922
+ * call-seq:
1923
+ * conn.sys_info(flags=0) -> String
1924
+ *
1925
+ * Call virConnectGetSysinfo[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetSysinfo]
1926
+ * to get machine-specific information about the hypervisor. This may include
1927
+ * data such as the host UUID, the BIOS version, etc.
1928
+ */
1929
+ static VALUE libvirt_connect_sys_info(int argc, VALUE *argv, VALUE c)
1930
+ {
1931
+ VALUE flags;
1932
+
1933
+ rb_scan_args(argc, argv, "01", &flags);
1934
+
1935
+ ruby_libvirt_generate_call_string(virConnectGetSysinfo,
1936
+ ruby_libvirt_connect_get(c), 1,
1937
+ ruby_libvirt_connect_get(c),
1938
+ ruby_libvirt_value_to_uint(flags));
1939
+ }
1940
+ #endif
1941
+
1942
+ #if HAVE_TYPE_VIRSTREAMPTR
1943
+
1944
+ /*
1945
+ * call-seq:
1946
+ * conn.stream(flags=0) -> Libvirt::Stream
1947
+ *
1948
+ * Call virStreamNew[http://www.libvirt.org/html/libvirt-libvirt-stream.html#virStreamNew]
1949
+ * to create a new stream.
1950
+ */
1951
+ static VALUE libvirt_connect_stream(int argc, VALUE *argv, VALUE c)
1952
+ {
1953
+ VALUE flags;
1954
+ virStreamPtr stream;
1955
+
1956
+ rb_scan_args(argc, argv, "01", &flags);
1957
+
1958
+ stream = virStreamNew(ruby_libvirt_connect_get(c),
1959
+ ruby_libvirt_value_to_uint(flags));
1960
+
1961
+ ruby_libvirt_raise_error_if(stream == NULL, e_RetrieveError,
1962
+ "virStreamNew", ruby_libvirt_connect_get(c));
1963
+
1964
+ return ruby_libvirt_stream_new(stream, c);
1965
+ }
1966
+ #endif
1967
+
1968
+ #if HAVE_VIRINTERFACECHANGEBEGIN
1969
+ /*
1970
+ * call-seq:
1971
+ * conn.interface_change_begin(flags=0) -> nil
1972
+ *
1973
+ * Call virInterfaceChangeBegin[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceChangeBegin]
1974
+ * to create a restore point for interface changes. Once changes have been
1975
+ * made, conn.interface_change_commit can be used to commit the result or
1976
+ * conn.interface_change_rollback can be used to rollback to this restore point.
1977
+ */
1978
+ static VALUE libvirt_connect_interface_change_begin(int argc, VALUE *argv,
1979
+ VALUE c)
1980
+ {
1981
+ VALUE flags;
1982
+
1983
+ rb_scan_args(argc, argv, "01", &flags);
1984
+
1985
+ ruby_libvirt_generate_call_nil(virInterfaceChangeBegin,
1986
+ ruby_libvirt_connect_get(c),
1987
+ ruby_libvirt_connect_get(c),
1988
+ ruby_libvirt_value_to_uint(flags));
1989
+ }
1990
+
1991
+ /*
1992
+ * call-seq:
1993
+ * conn.interface_change_commit(flags=0) -> nil
1994
+ *
1995
+ * Call virInterfaceChangeCommit[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceChangeCommit]
1996
+ * to commit the interface changes since the last conn.interface_change_begin.
1997
+ */
1998
+ static VALUE libvirt_connect_interface_change_commit(int argc, VALUE *argv,
1999
+ VALUE c)
2000
+ {
2001
+ VALUE flags;
2002
+
2003
+ rb_scan_args(argc, argv, "01", &flags);
2004
+
2005
+ ruby_libvirt_generate_call_nil(virInterfaceChangeCommit,
2006
+ ruby_libvirt_connect_get(c),
2007
+ ruby_libvirt_connect_get(c),
2008
+ ruby_libvirt_value_to_uint(flags));
2009
+ }
2010
+
2011
+ /*
2012
+ * call-seq:
2013
+ * conn.interface_change_rollback(flags=0) -> nil
2014
+ *
2015
+ * Call virInterfaceChangeRollback[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virInterfaceChangeRollback]
2016
+ * to rollback to the restore point saved by conn.interface_change_begin.
2017
+ */
2018
+ static VALUE libvirt_connect_interface_change_rollback(int argc, VALUE *argv,
2019
+ VALUE c)
2020
+ {
2021
+ VALUE flags;
2022
+
2023
+ rb_scan_args(argc, argv, "01", &flags);
2024
+
2025
+ ruby_libvirt_generate_call_nil(virInterfaceChangeRollback,
2026
+ ruby_libvirt_connect_get(c),
2027
+ ruby_libvirt_connect_get(c),
2028
+ ruby_libvirt_value_to_uint(flags));
2029
+ }
2030
+ #endif
2031
+
2032
+ #if HAVE_VIRNODEGETCPUSTATS
2033
+ static void cpu_stats_set(void *voidparams, int i, VALUE result)
2034
+ {
2035
+ virNodeCPUStatsPtr params = (virNodeCPUStatsPtr)voidparams;
2036
+
2037
+ rb_hash_aset(result, rb_str_new2(params[i].field),
2038
+ ULL2NUM(params[i].value));
2039
+ }
2040
+
2041
+ static const char *cpu_stats_nparams(VALUE d, unsigned int flags, void *opaque,
2042
+ int *nparams)
2043
+ {
2044
+ int intparam = *((int *)opaque);
2045
+
2046
+ if (virNodeGetCPUStats(ruby_libvirt_connect_get(d), intparam, NULL,
2047
+ nparams, flags) < 0) {
2048
+ return "virNodeGetCPUStats";
2049
+ }
2050
+
2051
+ return NULL;
2052
+ }
2053
+
2054
+ static const char *cpu_stats_get(VALUE d, unsigned int flags, void *voidparams,
2055
+ int *nparams, void *opaque)
2056
+ {
2057
+ int intparam = *((int *)opaque);
2058
+ virNodeCPUStatsPtr params = (virNodeCPUStatsPtr)voidparams;
2059
+
2060
+ if (virNodeGetCPUStats(ruby_libvirt_connect_get(d), intparam, params,
2061
+ nparams, flags) < 0) {
2062
+ return "virNodeGetCPUStats";
2063
+ }
2064
+
2065
+ return NULL;
2066
+ }
2067
+
2068
+ /*
2069
+ * call-seq:
2070
+ * conn.node_cpu_stats(cpuNum=-1, flags=0) -> Hash
2071
+ *
2072
+ * Call virNodeGetCPUStats[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetCPUStats]
2073
+ * to retrieve cpu statistics from the virtualization host.
2074
+ */
2075
+ static VALUE libvirt_connect_node_cpu_stats(int argc, VALUE *argv, VALUE c)
2076
+ {
2077
+ VALUE intparam, flags;
2078
+ int tmp;
2079
+
2080
+ rb_scan_args(argc, argv, "02", &intparam, &flags);
2081
+
2082
+ if (NIL_P(intparam)) {
2083
+ tmp = -1;
2084
+ }
2085
+ else {
2086
+ tmp = ruby_libvirt_value_to_int(intparam);
2087
+ }
2088
+
2089
+ return ruby_libvirt_get_parameters(c, ruby_libvirt_value_to_uint(flags),
2090
+ (void *)&tmp, sizeof(virNodeCPUStats),
2091
+ cpu_stats_nparams, cpu_stats_get,
2092
+ cpu_stats_set);
2093
+ }
2094
+ #endif
2095
+
2096
+ #if HAVE_VIRNODEGETMEMORYSTATS
2097
+ static void memory_stats_set(void *voidparams, int i, VALUE result)
2098
+ {
2099
+ virNodeMemoryStatsPtr params = (virNodeMemoryStatsPtr)voidparams;
2100
+
2101
+ rb_hash_aset(result, rb_str_new2(params[i].field),
2102
+ ULL2NUM(params[i].value));
2103
+ }
2104
+
2105
+ static const char *memory_stats_nparams(VALUE d, unsigned int flags,
2106
+ void *opaque, int *nparams)
2107
+ {
2108
+ int intparam = *((int *)opaque);
2109
+
2110
+ if (virNodeGetMemoryStats(ruby_libvirt_connect_get(d), intparam, NULL,
2111
+ nparams, flags) < 0) {
2112
+ return "virNodeGetMemoryStats";
2113
+ }
2114
+
2115
+ return NULL;
2116
+ }
2117
+
2118
+ static const char *memory_stats_get(VALUE d, unsigned int flags,
2119
+ void *voidparams, int *nparams,
2120
+ void *opaque)
2121
+ {
2122
+ int intparam = *((int *)opaque);
2123
+ virNodeMemoryStatsPtr params = (virNodeMemoryStatsPtr)voidparams;
2124
+
2125
+ if (virNodeGetMemoryStats(ruby_libvirt_connect_get(d), intparam, params,
2126
+ nparams, flags) < 0) {
2127
+ return "virNodeGetMemoryStats";
2128
+ }
2129
+
2130
+ return NULL;
2131
+ }
2132
+
2133
+ /*
2134
+ * call-seq:
2135
+ * conn.node_memory_stats(cellNum=-1, flags=0) -> Hash
2136
+ *
2137
+ * Call virNodeGetMemoryStats[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetMemoryStats]
2138
+ * to retrieve memory statistics from the virtualization host.
2139
+ */
2140
+ static VALUE libvirt_connect_node_memory_stats(int argc, VALUE *argv, VALUE c)
2141
+ {
2142
+ VALUE intparam, flags;
2143
+ int tmp;
2144
+
2145
+ rb_scan_args(argc, argv, "02", &intparam, &flags);
2146
+
2147
+ if (NIL_P(intparam)) {
2148
+ tmp = -1;
2149
+ }
2150
+ else {
2151
+ tmp = ruby_libvirt_value_to_int(intparam);
2152
+ }
2153
+
2154
+ return ruby_libvirt_get_parameters(c, ruby_libvirt_value_to_uint(flags),
2155
+ (void *)&tmp, sizeof(virNodeMemoryStats),
2156
+ memory_stats_nparams, memory_stats_get,
2157
+ memory_stats_set);
2158
+ }
2159
+ #endif
2160
+
2161
+ #if HAVE_VIRDOMAINSAVEIMAGEGETXMLDESC
2162
+ /*
2163
+ * call-seq:
2164
+ * conn.save_image_xml_desc(filename, flags=0) -> String
2165
+ *
2166
+ * Call virDomainSaveImageGetXMLDesc[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSaveImageGetXMLDesc]
2167
+ * to get the XML corresponding to a save file.
2168
+ */
2169
+ static VALUE libvirt_connect_save_image_xml_desc(int argc, VALUE *argv, VALUE c)
2170
+ {
2171
+ VALUE filename, flags;
2172
+
2173
+ rb_scan_args(argc, argv, "11", &filename, &flags);
2174
+
2175
+ ruby_libvirt_generate_call_string(virDomainSaveImageGetXMLDesc,
2176
+ ruby_libvirt_connect_get(c), 1,
2177
+ ruby_libvirt_connect_get(c),
2178
+ StringValueCStr(filename),
2179
+ ruby_libvirt_value_to_uint(flags));
2180
+ }
2181
+
2182
+ /*
2183
+ * call-seq:
2184
+ * conn.define_save_image_xml(filename, newxml, flags=0) -> nil
2185
+ *
2186
+ * Call virDomainSaveImageDefineXML[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainSaveImageDefineXML]
2187
+ * to define new XML for a saved image.
2188
+ */
2189
+ static VALUE libvirt_connect_define_save_image_xml(int argc, VALUE *argv,
2190
+ VALUE c)
2191
+ {
2192
+ VALUE filename, newxml, flags;
2193
+
2194
+ rb_scan_args(argc, argv, "21", &filename, &newxml, &flags);
2195
+
2196
+ ruby_libvirt_generate_call_nil(virDomainSaveImageDefineXML,
2197
+ ruby_libvirt_connect_get(c),
2198
+ ruby_libvirt_connect_get(c),
2199
+ StringValueCStr(filename),
2200
+ StringValueCStr(newxml),
2201
+ ruby_libvirt_value_to_uint(flags));
2202
+ }
2203
+ #endif
2204
+
2205
+ #if HAVE_VIRNODESUSPENDFORDURATION
2206
+ /*
2207
+ * call-seq:
2208
+ * conn.node_suspend_for_duration(target, duration, flags=0) -> nil
2209
+ *
2210
+ * Call virNodeSuspendForDuration[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeSuspendForDuration]
2211
+ * to suspend the hypervisor for the specified duration.
2212
+ */
2213
+ static VALUE libvirt_connect_node_suspend_for_duration(int argc, VALUE *argv,
2214
+ VALUE c)
2215
+ {
2216
+ VALUE target, duration, flags;
2217
+
2218
+ rb_scan_args(argc, argv, "21", &target, &duration, &flags);
2219
+
2220
+ ruby_libvirt_generate_call_nil(virNodeSuspendForDuration,
2221
+ ruby_libvirt_connect_get(c),
2222
+ ruby_libvirt_connect_get(c),
2223
+ NUM2UINT(target), NUM2ULL(duration),
2224
+ ruby_libvirt_value_to_uint(flags));
2225
+ }
2226
+ #endif
2227
+
2228
+ #if HAVE_VIRNODEGETMEMORYPARAMETERS
2229
+ static const char *node_memory_nparams(VALUE d, unsigned int flags,
2230
+ void *RUBY_LIBVIRT_UNUSED(opaque),
2231
+ int *nparams)
2232
+ {
2233
+ if (virNodeGetMemoryParameters(ruby_libvirt_connect_get(d), NULL, nparams,
2234
+ flags) < 0) {
2235
+ return "virNodeGetMemoryParameters";
2236
+ }
2237
+
2238
+ return NULL;
2239
+ }
2240
+
2241
+ static const char *node_memory_get(VALUE d, unsigned int flags,
2242
+ void *voidparams, int *nparams,
2243
+ void *RUBY_LIBVIRT_UNUSED(opaque))
2244
+ {
2245
+ virTypedParameterPtr params = (virTypedParameterPtr)voidparams;
2246
+
2247
+ if (virNodeGetMemoryParameters(ruby_libvirt_connect_get(d), params, nparams,
2248
+ flags) < 0) {
2249
+ return "virNodeGetMemoryParameters";
2250
+ }
2251
+ return NULL;
2252
+ }
2253
+
2254
+ static const char *node_memory_set(VALUE d, unsigned int flags,
2255
+ virTypedParameterPtr params, int nparams,
2256
+ void *RUBY_LIBVIRT_UNUSED(opaque))
2257
+ {
2258
+ if (virNodeSetMemoryParameters(ruby_libvirt_connect_get(d), params, nparams,
2259
+ flags) < 0) {
2260
+ return "virNodeSetMemoryParameters";
2261
+ }
2262
+ return NULL;
2263
+ }
2264
+
2265
+ /*
2266
+ * call-seq:
2267
+ * conn.node_memory_parameters(flags=0) -> Hash
2268
+ *
2269
+ * Call virNodeGetMemoryParameters[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetMemoryParameters]
2270
+ * to get information about memory on the host node.
2271
+ */
2272
+ static VALUE libvirt_connect_node_memory_parameters(int argc, VALUE *argv,
2273
+ VALUE c)
2274
+ {
2275
+ VALUE flags;
2276
+
2277
+ rb_scan_args(argc, argv, "01", &flags);
2278
+
2279
+ return ruby_libvirt_get_typed_parameters(c,
2280
+ ruby_libvirt_value_to_uint(flags),
2281
+ NULL, node_memory_nparams,
2282
+ node_memory_get);
2283
+ }
2284
+
2285
+ static struct ruby_libvirt_typed_param memory_allowed[] = {
2286
+ {VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN, VIR_TYPED_PARAM_UINT},
2287
+ {VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS, VIR_TYPED_PARAM_UINT},
2288
+ {VIR_NODE_MEMORY_SHARED_PAGES_SHARED, VIR_TYPED_PARAM_ULLONG},
2289
+ {VIR_NODE_MEMORY_SHARED_PAGES_SHARING, VIR_TYPED_PARAM_ULLONG},
2290
+ {VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED, VIR_TYPED_PARAM_ULLONG},
2291
+ {VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE, VIR_TYPED_PARAM_ULLONG},
2292
+ {VIR_NODE_MEMORY_SHARED_FULL_SCANS, VIR_TYPED_PARAM_ULLONG},
2293
+ #if HAVE_CONST_VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES
2294
+ {VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES, VIR_TYPED_PARAM_UINT},
2295
+ #endif
2296
+ };
2297
+
2298
+ /*
2299
+ * call-seq:
2300
+ * conn.node_memory_parameters = Hash,flags=0
2301
+ *
2302
+ * Call virNodeSetMemoryParameters[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeSetMemoryParameters]
2303
+ * to set the memory parameters for this host node.
2304
+ */
2305
+ static VALUE libvirt_connect_node_memory_parameters_equal(VALUE c, VALUE input)
2306
+ {
2307
+ VALUE hash, flags;
2308
+
2309
+ ruby_libvirt_assign_hash_and_flags(input, &hash, &flags);
2310
+
2311
+ return ruby_libvirt_set_typed_parameters(c, hash, NUM2UINT(flags), NULL,
2312
+ memory_allowed,
2313
+ ARRAY_SIZE(memory_allowed),
2314
+ node_memory_set);
2315
+ }
2316
+ #endif
2317
+
2318
+ #if HAVE_VIRNODEGETCPUMAP
2319
+ struct cpu_map_field_to_value {
2320
+ VALUE result;
2321
+ int cpu;
2322
+ int used;
2323
+ };
2324
+
2325
+ static VALUE cpu_map_field_to_value(VALUE input)
2326
+ {
2327
+ struct cpu_map_field_to_value *ftv = (struct cpu_map_field_to_value *)input;
2328
+ char cpuname[10];
2329
+
2330
+ snprintf(cpuname, sizeof(cpuname), "%d", ftv->cpu);
2331
+ rb_hash_aset(ftv->result, rb_str_new2(cpuname), ftv->used ? Qtrue : Qfalse);
2332
+
2333
+ return Qnil;
2334
+ }
2335
+
2336
+ /*
2337
+ * call-seq:
2338
+ * conn.node_cpu_map -> Hash
2339
+ *
2340
+ * Call virNodeGetCPUMap[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetCPUMap]
2341
+ * to get a map of online host CPUs.
2342
+ */
2343
+ static VALUE libvirt_connect_node_cpu_map(int argc, VALUE *argv, VALUE c)
2344
+ {
2345
+ VALUE flags, result;
2346
+ unsigned char *map;
2347
+ unsigned int online;
2348
+ int ret, i, exception = 0;
2349
+ struct cpu_map_field_to_value ftv;
2350
+
2351
+ rb_scan_args(argc, argv, "01", &flags);
2352
+
2353
+ ret = virNodeGetCPUMap(ruby_libvirt_connect_get(c), &map, &online,
2354
+ ruby_libvirt_value_to_uint(flags));
2355
+ ruby_libvirt_raise_error_if(ret < 0, e_RetrieveError, "virNodeGetCPUMap",
2356
+ ruby_libvirt_connect_get(c));
2357
+
2358
+ result = rb_hash_new();
2359
+
2360
+ for (i = 0; i < ret; i++) {
2361
+ ftv.result = result;
2362
+ ftv.cpu = i;
2363
+ ftv.used = VIR_CPU_USED(map, i);
2364
+ rb_protect(cpu_map_field_to_value, (VALUE)&ftv, &exception);
2365
+ if (exception) {
2366
+ free(map);
2367
+ rb_jump_tag(exception);
2368
+ }
2369
+ }
2370
+
2371
+ free(map);
2372
+
2373
+ return result;
2374
+ }
2375
+ #endif
2376
+
2377
+ #if HAVE_VIRCONNECTSETKEEPALIVE
2378
+ /*
2379
+ * call-seq:
2380
+ * conn.set_keepalive(interval, count) -> Fixnum
2381
+ *
2382
+ * Call virConnectSetKeepAlive[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectSetKeepAlive]
2383
+ * to start sending keepalive messages. Deprecated; use conn.keepalive=
2384
+ * instead.
2385
+ */
2386
+ static VALUE libvirt_connect_set_keepalive(VALUE c, VALUE interval, VALUE count)
2387
+ {
2388
+ ruby_libvirt_generate_call_int(virConnectSetKeepAlive,
2389
+ ruby_libvirt_connect_get(c),
2390
+ ruby_libvirt_connect_get(c),
2391
+ NUM2INT(interval), NUM2UINT(count));
2392
+ }
2393
+
2394
+ /*
2395
+ * call-seq:
2396
+ * conn.keepalive = interval,count
2397
+ *
2398
+ * Call virConnectSetKeepAlive[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectSetKeepAlive]
2399
+ * to start sending keepalive messages.
2400
+ */
2401
+ static VALUE libvirt_connect_keepalive_equal(VALUE c, VALUE in)
2402
+ {
2403
+ VALUE interval, count;
2404
+
2405
+ Check_Type(in, T_ARRAY);
2406
+
2407
+ if (RARRAY_LEN(in) != 2) {
2408
+ rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2)",
2409
+ RARRAY_LEN(in));
2410
+ }
2411
+
2412
+ interval = rb_ary_entry(in, 0);
2413
+ count = rb_ary_entry(in, 1);
2414
+
2415
+ ruby_libvirt_generate_call_int(virConnectSetKeepAlive,
2416
+ ruby_libvirt_connect_get(c),
2417
+ ruby_libvirt_connect_get(c),
2418
+ NUM2INT(interval), NUM2UINT(count));
2419
+ }
2420
+ #endif
2421
+
2422
+ #if HAVE_VIRCONNECTLISTALLDOMAINS
2423
+ /*
2424
+ * call-seq:
2425
+ * conn.list_all_domains(flags=0) -> Array
2426
+ *
2427
+ * Call virConnectListAllDomains[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectListAllDomains]
2428
+ * to get an array of domain objects for all domains.
2429
+ */
2430
+ static VALUE libvirt_connect_list_all_domains(int argc, VALUE *argv, VALUE c)
2431
+ {
2432
+ ruby_libvirt_generate_call_list_all(virDomainPtr, argc, argv,
2433
+ virConnectListAllDomains,
2434
+ ruby_libvirt_connect_get(c), c,
2435
+ ruby_libvirt_domain_new, virDomainFree);
2436
+ }
2437
+ #endif
2438
+
2439
+ #if HAVE_VIRCONNECTLISTALLNETWORKS
2440
+ /*
2441
+ * call-seq:
2442
+ * conn.list_all_networks(flags=0) -> Array
2443
+ *
2444
+ * Call virConnectListAllNetworks[http://www.libvirt.org/html/libvirt-libvirt-network.html#virConnectListAllNetworks]
2445
+ * to get an array of network objects for all networks.
2446
+ */
2447
+ static VALUE libvirt_connect_list_all_networks(int argc, VALUE *argv, VALUE c)
2448
+ {
2449
+ ruby_libvirt_generate_call_list_all(virNetworkPtr, argc, argv,
2450
+ virConnectListAllNetworks,
2451
+ ruby_libvirt_connect_get(c), c,
2452
+ ruby_libvirt_network_new,
2453
+ virNetworkFree);
2454
+ }
2455
+ #endif
2456
+
2457
+ #if HAVE_VIRCONNECTLISTALLINTERFACES
2458
+ /*
2459
+ * call-seq:
2460
+ * conn.list_all_interfaces(flags=0) -> Array
2461
+ *
2462
+ * Call virConnectListAllInterfaces[http://www.libvirt.org/html/libvirt-libvirt-interface.html#virConnectListAllInterfaces]
2463
+ * to get an array of interface objects for all interfaces.
2464
+ */
2465
+ static VALUE libvirt_connect_list_all_interfaces(int argc, VALUE *argv, VALUE c)
2466
+ {
2467
+ ruby_libvirt_generate_call_list_all(virInterfacePtr, argc, argv,
2468
+ virConnectListAllInterfaces,
2469
+ ruby_libvirt_connect_get(c), c,
2470
+ ruby_libvirt_interface_new,
2471
+ virInterfaceFree);
2472
+ }
2473
+ #endif
2474
+
2475
+ #if HAVE_VIRCONNECTLISTALLSECRETS
2476
+ /*
2477
+ * call-seq:
2478
+ * conn.list_all_secrets(flags=0) -> Array
2479
+ *
2480
+ * Call virConnectListAllSecrets[http://www.libvirt.org/html/libvirt-libvirt-secret.html#virConnectListAllSecrets]
2481
+ * to get an array of secret objects for all secrets.
2482
+ */
2483
+ static VALUE libvirt_connect_list_all_secrets(int argc, VALUE *argv, VALUE c)
2484
+ {
2485
+ ruby_libvirt_generate_call_list_all(virSecretPtr, argc, argv,
2486
+ virConnectListAllSecrets,
2487
+ ruby_libvirt_connect_get(c), c,
2488
+ ruby_libvirt_secret_new, virSecretFree);
2489
+ }
2490
+ #endif
2491
+
2492
+ #if HAVE_VIRCONNECTLISTALLNODEDEVICES
2493
+ /*
2494
+ * call-seq:
2495
+ * conn.list_all_nodedevices(flags=0) -> Array
2496
+ *
2497
+ * Call virConnectListAllNodeDevices[http://www.libvirt.org/html/libvirt-libvirt-nodedev.html#virConnectListAllNodeDevices]
2498
+ * to get an array of nodedevice objects for all nodedevices.
2499
+ */
2500
+ static VALUE libvirt_connect_list_all_nodedevices(int argc, VALUE *argv,
2501
+ VALUE c)
2502
+ {
2503
+ ruby_libvirt_generate_call_list_all(virNodeDevicePtr, argc, argv,
2504
+ virConnectListAllNodeDevices,
2505
+ ruby_libvirt_connect_get(c), c,
2506
+ ruby_libvirt_nodedevice_new,
2507
+ virNodeDeviceFree);
2508
+ }
2509
+ #endif
2510
+
2511
+ #if HAVE_VIRCONNECTLISTALLSTORAGEPOOLS
2512
+ /*
2513
+ * call-seq:
2514
+ * conn.list_all_storage_pools(flags=0) -> Array
2515
+ *
2516
+ * Call virConnectListAllStoragePools[http://www.libvirt.org/html/libvirt-libvirt-storage.html#virConnectListAllStoragePools]
2517
+ * to get an array of storage pool objects for all storage pools.
2518
+ */
2519
+ static VALUE libvirt_connect_list_all_storage_pools(int argc, VALUE *argv,
2520
+ VALUE c)
2521
+ {
2522
+ ruby_libvirt_generate_call_list_all(virStoragePoolPtr, argc, argv,
2523
+ virConnectListAllStoragePools,
2524
+ ruby_libvirt_connect_get(c), c,
2525
+ pool_new, virStoragePoolFree);
2526
+ }
2527
+ #endif
2528
+
2529
+ #if HAVE_VIRCONNECTLISTALLNWFILTERS
2530
+ /*
2531
+ * call-seq:
2532
+ * conn.list_all_nwfilters(flags=0) -> Array
2533
+ *
2534
+ * Call virConnectListAllNWFilters[http://www.libvirt.org/html/libvirt-libvirt-nwfilter.html#virConnectListAllNWFilters]
2535
+ * to get an array of nwfilters for all nwfilter objects.
2536
+ */
2537
+ static VALUE libvirt_connect_list_all_nwfilters(int argc, VALUE *argv, VALUE c)
2538
+ {
2539
+ ruby_libvirt_generate_call_list_all(virNWFilterPtr, argc, argv,
2540
+ virConnectListAllNWFilters,
2541
+ ruby_libvirt_connect_get(c), c,
2542
+ ruby_libvirt_nwfilter_new,
2543
+ virNWFilterFree);
2544
+ }
2545
+ #endif
2546
+
2547
+ #if HAVE_VIRCONNECTISALIVE
2548
+ /*
2549
+ * call-seq:
2550
+ * conn.alive? -> [True|False]
2551
+ *
2552
+ * Call virConnectIsAlive[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectIsAlive]
2553
+ * to determine if the connection is alive.
2554
+ */
2555
+ static VALUE libvirt_connect_alive_p(VALUE c)
2556
+ {
2557
+ ruby_libvirt_generate_call_truefalse(virConnectIsAlive,
2558
+ ruby_libvirt_connect_get(c),
2559
+ ruby_libvirt_connect_get(c));
2560
+ }
2561
+ #endif
2562
+
2563
+ #if HAVE_VIRDOMAINCREATEXMLWITHFILES
2564
+ /*
2565
+ * call-seq:
2566
+ * conn.create_domain_xml_with_files(xml, fds=nil, flags=0) -> Libvirt::Domain
2567
+ *
2568
+ * Call virDomainCreateXMLWithFiles[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virDomainCreateXMLWithFiles]
2569
+ * to launch a new guest domain with a set of open file descriptors.
2570
+ */
2571
+ static VALUE libvirt_connect_create_domain_xml_with_files(int argc, VALUE *argv,
2572
+ VALUE c)
2573
+ {
2574
+ VALUE xml, fds, flags;
2575
+ int *files;
2576
+ unsigned int numfiles, i;
2577
+ virDomainPtr dom;
2578
+
2579
+ rb_scan_args(argc, argv, "12", &xml, &fds, &flags);
2580
+
2581
+ Check_Type(xml, T_STRING);
2582
+
2583
+ if (TYPE(fds) == T_NIL) {
2584
+ files = NULL;
2585
+ numfiles = 0;
2586
+ }
2587
+ else if (TYPE(fds) == T_ARRAY) {
2588
+ numfiles = RARRAY_LEN(fds);
2589
+ files = alloca(numfiles * sizeof(int));
2590
+ for (i = 0; i < numfiles; i++) {
2591
+ files[i] = NUM2INT(rb_ary_entry(fds, i));
2592
+ }
2593
+ }
2594
+ else {
2595
+ rb_raise(rb_eTypeError, "wrong argument type (expected Array)");
2596
+ }
2597
+
2598
+ dom = virDomainCreateXMLWithFiles(ruby_libvirt_connect_get(c),
2599
+ ruby_libvirt_get_cstring_or_null(xml),
2600
+ numfiles, files,
2601
+ ruby_libvirt_value_to_uint(flags));
2602
+ ruby_libvirt_raise_error_if(dom == NULL, e_Error,
2603
+ "virDomainCreateXMLWithFiles",
2604
+ ruby_libvirt_connect_get(c));
2605
+
2606
+ return ruby_libvirt_domain_new(dom, c);
2607
+ }
2608
+ #endif
2609
+
2610
+ #if HAVE_VIRDOMAINQEMUATTACH
2611
+ /*
2612
+ * call-seq:
2613
+ * conn.qemu_attach(pid, flags=0) -> Libvirt::Domain
2614
+ *
2615
+ * Call virDomainQemuAttach
2616
+ * to attach to the Qemu process pid.
2617
+ */
2618
+ static VALUE libvirt_connect_qemu_attach(int argc, VALUE *argv, VALUE c)
2619
+ {
2620
+ VALUE pid, flags;
2621
+ virDomainPtr dom;
2622
+
2623
+ rb_scan_args(argc, argv, "11", &pid, &flags);
2624
+
2625
+ dom = virDomainQemuAttach(ruby_libvirt_connect_get(c), NUM2UINT(pid),
2626
+ ruby_libvirt_value_to_uint(flags));
2627
+ ruby_libvirt_raise_error_if(dom == NULL, e_Error, "virDomainQemuAttach",
2628
+ ruby_libvirt_connect_get(c));
2629
+
2630
+ return ruby_libvirt_domain_new(dom, c);
2631
+ }
2632
+ #endif
2633
+
2634
+ #if HAVE_VIRCONNECTGETCPUMODELNAMES
2635
+ /*
2636
+ * call-seq:
2637
+ * conn.cpu_model_names(arch, flags=0) -> Array
2638
+ *
2639
+ * Call virConnectGetCPUModelNames[http://www.libvirt.org/html/libvirt-libvirt-host.html#virConnectGetCPUModelNames]
2640
+ * to get an array of CPU model names.
2641
+ */
2642
+ static VALUE libvirt_connect_cpu_model_names(int argc, VALUE *argv, VALUE c)
2643
+ {
2644
+ VALUE arch, flags, result;
2645
+ char **models;
2646
+ int i = 0, j, elems = 0;
2647
+ struct ruby_libvirt_str_new2_and_ary_store_arg args;
2648
+ int exception;
2649
+
2650
+ rb_scan_args(argc, argv, "11", &arch, &flags);
2651
+
2652
+ elems = virConnectGetCPUModelNames(ruby_libvirt_connect_get(c),
2653
+ StringValueCStr(arch), &models,
2654
+ ruby_libvirt_value_to_uint(flags));
2655
+ ruby_libvirt_raise_error_if(elems < 0, e_RetrieveError,
2656
+ "virConnectGetCPUModelNames",
2657
+ ruby_libvirt_connect_get(c));
2658
+
2659
+ result = rb_protect(ruby_libvirt_ary_new2_wrap, (VALUE)&elems, &exception);
2660
+ if (exception) {
2661
+ goto error;
2662
+ }
2663
+
2664
+ for (i = 0; i < elems; i++) {
2665
+ args.arr = result;
2666
+ args.index = i;
2667
+ args.value = models[i];
2668
+
2669
+ rb_protect(ruby_libvirt_str_new2_and_ary_store_wrap, (VALUE)&args,
2670
+ &exception);
2671
+ if (exception) {
2672
+ goto error;
2673
+ }
2674
+ free(models[i]);
2675
+ }
2676
+ free(models);
2677
+
2678
+ return result;
2679
+
2680
+ error:
2681
+ for (j = i; j < elems; j++) {
2682
+ free(models[j]);
2683
+ }
2684
+ free(models);
2685
+
2686
+ rb_jump_tag(exception);
2687
+ return Qnil;
2688
+ }
2689
+ #endif
2690
+
2691
+ #if HAVE_VIRNODEALLOCPAGES
2692
+ /*
2693
+ * call-seq:
2694
+ * conn.node_alloc_pages(page_arr, cells=nil, flags=0) -> Fixnum
2695
+ *
2696
+ * Call virNodeAllocPages[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeAllocPages]
2697
+ * to reserve huge pages in the system pool.
2698
+ */
2699
+ static VALUE libvirt_connect_node_alloc_pages(int argc, VALUE *argv, VALUE c)
2700
+ {
2701
+ VALUE page_arr, cells, flags, entry, size, count, tmp;
2702
+ int i, arraylen, start_cell, ret;
2703
+ unsigned int *page_sizes;
2704
+ unsigned long long *page_counts;
2705
+ unsigned int cell_count;
2706
+
2707
+ rb_scan_args(argc, argv, "12", &page_arr, &cells, &flags);
2708
+
2709
+ Check_Type(page_arr, T_ARRAY);
2710
+
2711
+ arraylen = RARRAY_LEN(page_arr);
2712
+
2713
+ page_sizes = alloca(arraylen * sizeof(unsigned int));
2714
+ page_counts = alloca(arraylen * sizeof(unsigned long long));
2715
+
2716
+ for (i = 0; i < arraylen; i++) {
2717
+ entry = rb_ary_entry(page_arr, i);
2718
+ Check_Type(entry, T_HASH);
2719
+
2720
+ size = rb_hash_aref(entry, rb_str_new2("size"));
2721
+ Check_Type(size, T_FIXNUM);
2722
+
2723
+ count = rb_hash_aref(entry, rb_str_new2("count"));
2724
+ Check_Type(count, T_FIXNUM);
2725
+
2726
+ page_sizes[i] = NUM2UINT(size);
2727
+ page_counts[i] = NUM2ULL(count);
2728
+ }
2729
+
2730
+ if (NIL_P(cells)) {
2731
+ start_cell = -1;
2732
+ cell_count = 0;
2733
+ }
2734
+ else {
2735
+ Check_Type(cells, T_HASH);
2736
+
2737
+ tmp = rb_hash_aref(cells, rb_str_new2("start"));
2738
+ Check_Type(tmp, T_FIXNUM);
2739
+ start_cell = NUM2INT(tmp);
2740
+
2741
+ tmp = rb_hash_aref(cells, rb_str_new2("count"));
2742
+ Check_Type(tmp, T_FIXNUM);
2743
+ cell_count = NUM2UINT(tmp);
2744
+ }
2745
+
2746
+ ret = virNodeAllocPages(ruby_libvirt_connect_get(c), arraylen, page_sizes,
2747
+ page_counts, start_cell, cell_count,
2748
+ ruby_libvirt_value_to_uint(flags));
2749
+ ruby_libvirt_raise_error_if(ret < 0, e_Error,
2750
+ "virNodeAllocPages",
2751
+ ruby_libvirt_connect_get(c));
2752
+
2753
+ return INT2NUM(ret);
2754
+ }
2755
+ #endif
2756
+
2757
+ #if HAVE_VIRCONNECTGETDOMAINCAPABILITIES
2758
+ /*
2759
+ * call-seq:
2760
+ * conn.domain_capabilities(emulatorbin, arch, machine, virttype, flags=0) -> String
2761
+ *
2762
+ * Call virConnectGetDomainCapabilities[http://www.libvirt.org/html/libvirt-libvirt-domain.html#virConnectGetDomainCapabilities]
2763
+ * to get the capabilities of the underlying emulator.
2764
+ */
2765
+ static VALUE libvirt_connect_domain_capabilities(int argc, VALUE *argv, VALUE c)
2766
+ {
2767
+ VALUE emulatorbin, arch, machine, virttype, flags;
2768
+
2769
+ rb_scan_args(argc, argv, "41", &emulatorbin, &arch, &machine, &virttype,
2770
+ &flags);
2771
+
2772
+ ruby_libvirt_generate_call_string(virConnectGetDomainCapabilities,
2773
+ ruby_libvirt_connect_get(c), 1,
2774
+ ruby_libvirt_connect_get(c),
2775
+ ruby_libvirt_get_cstring_or_null(emulatorbin),
2776
+ ruby_libvirt_get_cstring_or_null(arch),
2777
+ ruby_libvirt_get_cstring_or_null(machine),
2778
+ ruby_libvirt_get_cstring_or_null(virttype),
2779
+ NUM2UINT(flags));
2780
+ }
2781
+ #endif
2782
+
2783
+ #if HAVE_VIRNODEGETFREEPAGES
2784
+ /*
2785
+ * call-seq:
2786
+ * conn.node_free_pages(pages, cells, flags=0) -> Hash
2787
+ *
2788
+ * Call virNodeGetFreePages[http://www.libvirt.org/html/libvirt-libvirt-host.html#virNodeGetFreePages]
2789
+ * to query the host system on free pages of specified size.
2790
+ */
2791
+ static VALUE libvirt_connect_node_free_pages(int argc, VALUE *argv, VALUE c)
2792
+ {
2793
+ VALUE pageArr = RUBY_Qnil, cells = RUBY_Qnil, flags = RUBY_Qnil, result;
2794
+ unsigned int *pages;
2795
+ unsigned int npages, i, cellCount;
2796
+ int startCell, ret;
2797
+ unsigned long long *counts;
2798
+
2799
+ rb_scan_args(argc, argv, "21", &pageArr, &cells, &flags);
2800
+
2801
+ Check_Type(pageArr, T_ARRAY);
2802
+ Check_Type(cells, T_HASH);
2803
+
2804
+ npages = RARRAY_LEN(pageArr);
2805
+ pages = alloca(npages);
2806
+ for (i = 0; i < npages; i++) {
2807
+ pages[i] = NUM2UINT(rb_ary_entry(pageArr, i));
2808
+ }
2809
+
2810
+ startCell = NUM2INT(rb_hash_aref(cells, rb_str_new2("startCell")));
2811
+ cellCount = NUM2UINT(rb_hash_aref(cells, rb_str_new2("cellCount")));
2812
+
2813
+ counts = alloca(npages * cellCount * sizeof(long long));
2814
+
2815
+ ret = virNodeGetFreePages(ruby_libvirt_connect_get(c), npages, pages,
2816
+ startCell, cellCount, counts,
2817
+ ruby_libvirt_value_to_uint(flags));
2818
+ ruby_libvirt_raise_error_if(ret < 0, e_Error, "virNodeGetFreePages",
2819
+ ruby_libvirt_connect_get(c));
2820
+
2821
+ result = rb_hash_new();
2822
+ for (i = 0; i < npages; i++) {
2823
+ rb_hash_aset(result, UINT2NUM(pages[i]), ULL2NUM(counts[i]));
2824
+ }
2825
+
2826
+ return result;
2827
+ }
2828
+ #endif
2829
+
2830
+ /*
2831
+ * Class Libvirt::Connect
2832
+ */
2833
+ void ruby_libvirt_connect_init(void)
2834
+ {
2835
+ c_connect = rb_define_class_under(m_libvirt, "Connect", rb_cObject);
2836
+
2837
+ /*
2838
+ * Class Libvirt::Connect::Nodeinfo
2839
+ */
2840
+ c_node_info = rb_define_class_under(c_connect, "Nodeinfo", rb_cObject);
2841
+ rb_define_attr(c_node_info, "model", 1, 0);
2842
+ rb_define_attr(c_node_info, "memory", 1, 0);
2843
+ rb_define_attr(c_node_info, "cpus", 1, 0);
2844
+ rb_define_attr(c_node_info, "mhz", 1, 0);
2845
+ rb_define_attr(c_node_info, "nodes", 1, 0);
2846
+ rb_define_attr(c_node_info, "sockets", 1, 0);
2847
+ rb_define_attr(c_node_info, "cores", 1, 0);
2848
+ rb_define_attr(c_node_info, "threads", 1, 0);
2849
+
2850
+ /*
2851
+ * Class Libvirt::Connect::NodeSecurityModel
2852
+ */
2853
+ c_node_security_model = rb_define_class_under(c_connect,
2854
+ "NodeSecurityModel",
2855
+ rb_cObject);
2856
+ rb_define_attr(c_node_security_model, "model", 1, 0);
2857
+ rb_define_attr(c_node_security_model, "doi", 1, 0);
2858
+
2859
+ rb_define_method(c_connect, "close", libvirt_connect_close, 0);
2860
+ rb_define_method(c_connect, "closed?", libvirt_connect_closed_p, 0);
2861
+ rb_define_method(c_connect, "type", libvirt_connect_type, 0);
2862
+ rb_define_method(c_connect, "version", libvirt_connect_version, 0);
2863
+ #if HAVE_VIRCONNECTGETLIBVERSION
2864
+ rb_define_method(c_connect, "libversion", libvirt_connect_libversion, 0);
2865
+ #endif
2866
+ rb_define_method(c_connect, "hostname", libvirt_connect_hostname, 0);
2867
+ rb_define_method(c_connect, "uri", libvirt_connect_uri, 0);
2868
+ rb_define_method(c_connect, "max_vcpus", libvirt_connect_max_vcpus, -1);
2869
+ rb_define_method(c_connect, "node_info", libvirt_connect_node_info, 0);
2870
+ rb_define_alias(c_connect, "node_get_info", "node_info");
2871
+ rb_define_method(c_connect, "node_free_memory",
2872
+ libvirt_connect_node_free_memory, 0);
2873
+ rb_define_method(c_connect, "node_cells_free_memory",
2874
+ libvirt_connect_node_cells_free_memory, -1);
2875
+ #if HAVE_VIRNODEGETSECURITYMODEL
2876
+ rb_define_method(c_connect, "node_security_model",
2877
+ libvirt_connect_node_security_model, 0);
2878
+ rb_define_alias(c_connect, "node_get_security_model",
2879
+ "node_security_model");
2880
+ #endif
2881
+ #if HAVE_VIRCONNECTISENCRYPTED
2882
+ rb_define_method(c_connect, "encrypted?", libvirt_connect_encrypted_p, 0);
2883
+ #endif
2884
+ #if HAVE_VIRCONNECTISSECURE
2885
+ rb_define_method(c_connect, "secure?", libvirt_connect_secure_p, 0);
2886
+ #endif
2887
+ rb_define_method(c_connect, "capabilities", libvirt_connect_capabilities,
2888
+ 0);
2889
+
2890
+ #if HAVE_VIRCONNECTCOMPARECPU
2891
+ rb_define_const(c_connect, "CPU_COMPARE_ERROR",
2892
+ INT2NUM(VIR_CPU_COMPARE_ERROR));
2893
+ rb_define_const(c_connect, "CPU_COMPARE_INCOMPATIBLE",
2894
+ INT2NUM(VIR_CPU_COMPARE_INCOMPATIBLE));
2895
+ rb_define_const(c_connect, "CPU_COMPARE_IDENTICAL",
2896
+ INT2NUM(VIR_CPU_COMPARE_IDENTICAL));
2897
+ rb_define_const(c_connect, "CPU_COMPARE_SUPERSET",
2898
+ INT2NUM(VIR_CPU_COMPARE_SUPERSET));
2899
+
2900
+ rb_define_method(c_connect, "compare_cpu", libvirt_connect_compare_cpu, -1);
2901
+ #endif
2902
+
2903
+ #if HAVE_CONST_VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE
2904
+ rb_define_const(c_connect, "COMPARE_CPU_FAIL_INCOMPATIBLE",
2905
+ INT2NUM(VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE));
2906
+ #endif
2907
+
2908
+ #if HAVE_VIRCONNECTBASELINECPU
2909
+ rb_define_method(c_connect, "baseline_cpu", libvirt_connect_baseline_cpu,
2910
+ -1);
2911
+ #endif
2912
+ #if HAVE_CONST_VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES
2913
+ rb_define_const(c_connect, "BASELINE_CPU_EXPAND_FEATURES",
2914
+ INT2NUM(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES));
2915
+ #endif
2916
+
2917
+ /* In the libvirt development history, the events were
2918
+ * first defined in commit 1509b8027fd0b73c30aeab443f81dd5a18d80544,
2919
+ * then ADDED and REMOVED were renamed to DEFINED and UNDEFINED at
2920
+ * the same time that the details were added
2921
+ * (d3d54d2fc92e350f250eda26cee5d0342416a9cf). What this means is that
2922
+ * we have to check for HAVE_CONST_VIR_DOMAIN_EVENT_DEFINED and
2923
+ * HAVE_CONST_VIR_DOMAIN_EVENT_STARTED to untangle these, and then we
2924
+ * can make a decision for many of the events based on that.
2925
+ */
2926
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_DEFINED
2927
+ rb_define_const(c_connect, "DOMAIN_EVENT_DEFINED",
2928
+ INT2NUM(VIR_DOMAIN_EVENT_DEFINED));
2929
+ rb_define_const(c_connect, "DOMAIN_EVENT_DEFINED_ADDED",
2930
+ INT2NUM(VIR_DOMAIN_EVENT_DEFINED_ADDED));
2931
+ rb_define_const(c_connect, "DOMAIN_EVENT_DEFINED_UPDATED",
2932
+ INT2NUM(VIR_DOMAIN_EVENT_DEFINED_UPDATED));
2933
+ rb_define_const(c_connect, "DOMAIN_EVENT_UNDEFINED",
2934
+ INT2NUM(VIR_DOMAIN_EVENT_UNDEFINED));
2935
+ rb_define_const(c_connect, "DOMAIN_EVENT_UNDEFINED_REMOVED",
2936
+ INT2NUM(VIR_DOMAIN_EVENT_UNDEFINED_REMOVED));
2937
+ rb_define_const(c_connect, "DOMAIN_EVENT_STARTED_BOOTED",
2938
+ INT2NUM(VIR_DOMAIN_EVENT_STARTED_BOOTED));
2939
+ rb_define_const(c_connect, "DOMAIN_EVENT_STARTED_MIGRATED",
2940
+ INT2NUM(VIR_DOMAIN_EVENT_STARTED_MIGRATED));
2941
+ rb_define_const(c_connect, "DOMAIN_EVENT_STARTED_RESTORED",
2942
+ INT2NUM(VIR_DOMAIN_EVENT_STARTED_RESTORED));
2943
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_PAUSED",
2944
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_PAUSED));
2945
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_MIGRATED",
2946
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED));
2947
+ rb_define_const(c_connect, "DOMAIN_EVENT_RESUMED_UNPAUSED",
2948
+ INT2NUM(VIR_DOMAIN_EVENT_RESUMED_UNPAUSED));
2949
+ rb_define_const(c_connect, "DOMAIN_EVENT_RESUMED_MIGRATED",
2950
+ INT2NUM(VIR_DOMAIN_EVENT_RESUMED_MIGRATED));
2951
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_SHUTDOWN",
2952
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN));
2953
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_DESTROYED",
2954
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_DESTROYED));
2955
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_CRASHED",
2956
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_CRASHED));
2957
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_MIGRATED",
2958
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_MIGRATED));
2959
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_SAVED",
2960
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_SAVED));
2961
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_FAILED",
2962
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_FAILED));
2963
+ #endif
2964
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_STARTED
2965
+ rb_define_const(c_connect, "DOMAIN_EVENT_STARTED",
2966
+ INT2NUM(VIR_DOMAIN_EVENT_STARTED));
2967
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED",
2968
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED));
2969
+ rb_define_const(c_connect, "DOMAIN_EVENT_RESUMED",
2970
+ INT2NUM(VIR_DOMAIN_EVENT_RESUMED));
2971
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED",
2972
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED));
2973
+ #endif
2974
+ #if HAVE_TYPE_VIRDOMAINSNAPSHOTPTR
2975
+ rb_define_const(c_connect, "DOMAIN_EVENT_STARTED_FROM_SNAPSHOT",
2976
+ INT2NUM(VIR_DOMAIN_EVENT_STARTED_FROM_SNAPSHOT));
2977
+ rb_define_const(c_connect, "DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT",
2978
+ INT2NUM(VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT));
2979
+ #endif
2980
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_IOERROR
2981
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_IOERROR",
2982
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_IOERROR));
2983
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_WATCHDOG",
2984
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG));
2985
+ #endif
2986
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_WATCHDOG
2987
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_WATCHDOG",
2988
+ INT2NUM(VIR_DOMAIN_EVENT_ID_WATCHDOG));
2989
+ rb_define_const(c_connect, "DOMAIN_EVENT_WATCHDOG_NONE",
2990
+ INT2NUM(VIR_DOMAIN_EVENT_WATCHDOG_NONE));
2991
+ rb_define_const(c_connect, "DOMAIN_EVENT_WATCHDOG_PAUSE",
2992
+ INT2NUM(VIR_DOMAIN_EVENT_WATCHDOG_PAUSE));
2993
+ rb_define_const(c_connect, "DOMAIN_EVENT_WATCHDOG_RESET",
2994
+ INT2NUM(VIR_DOMAIN_EVENT_WATCHDOG_RESET));
2995
+ rb_define_const(c_connect, "DOMAIN_EVENT_WATCHDOG_POWEROFF",
2996
+ INT2NUM(VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF));
2997
+ rb_define_const(c_connect, "DOMAIN_EVENT_WATCHDOG_SHUTDOWN",
2998
+ INT2NUM(VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN));
2999
+ rb_define_const(c_connect, "DOMAIN_EVENT_WATCHDOG_DEBUG",
3000
+ INT2NUM(VIR_DOMAIN_EVENT_WATCHDOG_DEBUG));
3001
+ #endif
3002
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_IO_ERROR
3003
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_IO_ERROR",
3004
+ INT2NUM(VIR_DOMAIN_EVENT_ID_IO_ERROR));
3005
+ rb_define_const(c_connect, "DOMAIN_EVENT_IO_ERROR_NONE",
3006
+ INT2NUM(VIR_DOMAIN_EVENT_IO_ERROR_NONE));
3007
+ rb_define_const(c_connect, "DOMAIN_EVENT_IO_ERROR_PAUSE",
3008
+ INT2NUM(VIR_DOMAIN_EVENT_IO_ERROR_PAUSE));
3009
+ rb_define_const(c_connect, "DOMAIN_EVENT_IO_ERROR_REPORT",
3010
+ INT2NUM(VIR_DOMAIN_EVENT_IO_ERROR_REPORT));
3011
+ #endif
3012
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_GRAPHICS
3013
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_GRAPHICS",
3014
+ INT2NUM(VIR_DOMAIN_EVENT_ID_GRAPHICS));
3015
+ rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_CONNECT",
3016
+ INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_CONNECT));
3017
+ rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_INITIALIZE",
3018
+ INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE));
3019
+ rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_DISCONNECT",
3020
+ INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT));
3021
+ rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4",
3022
+ INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4));
3023
+ rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6",
3024
+ INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6));
3025
+ #endif
3026
+ #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY
3027
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_LIFECYCLE",
3028
+ INT2NUM(VIR_DOMAIN_EVENT_ID_LIFECYCLE));
3029
+ #endif
3030
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_REBOOT
3031
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_REBOOT",
3032
+ INT2NUM(VIR_DOMAIN_EVENT_ID_REBOOT));
3033
+ #endif
3034
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_RTC_CHANGE
3035
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_RTC_CHANGE",
3036
+ INT2NUM(VIR_DOMAIN_EVENT_ID_RTC_CHANGE));
3037
+ #endif
3038
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON
3039
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_IO_ERROR_REASON",
3040
+ INT2NUM(VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON));
3041
+ #endif
3042
+
3043
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_ID_CONTROL_ERROR
3044
+ rb_define_const(c_connect, "DOMAIN_EVENT_ID_CONTROL_ERROR",
3045
+ INT2NUM(VIR_DOMAIN_EVENT_ID_CONTROL_ERROR));
3046
+ #endif
3047
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_SHUTDOWN
3048
+ rb_define_const(c_connect, "DOMAIN_EVENT_SHUTDOWN",
3049
+ INT2NUM(VIR_DOMAIN_EVENT_SHUTDOWN));
3050
+ #endif
3051
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_PMSUSPENDED
3052
+ rb_define_const(c_connect, "DOMAIN_EVENT_PMSUSPENDED",
3053
+ INT2NUM(VIR_DOMAIN_EVENT_PMSUSPENDED));
3054
+ #endif
3055
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_CRASHED
3056
+ rb_define_const(c_connect, "DOMAIN_EVENT_CRASHED",
3057
+ INT2NUM(VIR_DOMAIN_EVENT_CRASHED));
3058
+ #endif
3059
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_STARTED_WAKEUP
3060
+ rb_define_const(c_connect, "DOMAIN_EVENT_STARTED_WAKEUP",
3061
+ INT2NUM(VIR_DOMAIN_EVENT_STARTED_WAKEUP));
3062
+ #endif
3063
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_RESTORED
3064
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_RESTORED",
3065
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_RESTORED));
3066
+ #endif
3067
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT
3068
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT",
3069
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_FROM_SNAPSHOT));
3070
+ #endif
3071
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR
3072
+ rb_define_const(c_connect, "DOMAIN_EVENT_SUSPENDED_API_ERROR",
3073
+ INT2NUM(VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR));
3074
+ #endif
3075
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT
3076
+ rb_define_const(c_connect, "DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT",
3077
+ INT2NUM(VIR_DOMAIN_EVENT_RESUMED_FROM_SNAPSHOT));
3078
+ #endif
3079
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED
3080
+ rb_define_const(c_connect, "DOMAIN_EVENT_SHUTDOWN_FINISHED",
3081
+ INT2NUM(VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED));
3082
+ #endif
3083
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY
3084
+ rb_define_const(c_connect, "DOMAIN_EVENT_PMSUSPENDED_MEMORY",
3085
+ INT2NUM(VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY));
3086
+ #endif
3087
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_PMSUSPENDED_DISK
3088
+ rb_define_const(c_connect, "DOMAIN_EVENT_PMSUSPENDED_DISK",
3089
+ INT2NUM(VIR_DOMAIN_EVENT_PMSUSPENDED_DISK));
3090
+ #endif
3091
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_CRASHED_PANICKED
3092
+ rb_define_const(c_connect, "DOMAIN_EVENT_CRASHED_PANICKED",
3093
+ INT2NUM(VIR_DOMAIN_EVENT_CRASHED_PANICKED));
3094
+ #endif
3095
+ #if HAVE_CONST_VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX
3096
+ rb_define_const(c_connect, "DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX",
3097
+ INT2NUM(VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX));
3098
+ #endif
3099
+
3100
+ #if HAVE_VIRCONNECTDOMAINEVENTREGISTER
3101
+ rb_define_method(c_connect, "domain_event_register",
3102
+ libvirt_connect_domain_event_register, -1);
3103
+ rb_define_method(c_connect, "domain_event_deregister",
3104
+ libvirt_connect_domain_event_deregister, 0);
3105
+ #endif
3106
+
3107
+ #if HAVE_VIRCONNECTDOMAINEVENTREGISTERANY
3108
+ rb_define_method(c_connect, "domain_event_register_any",
3109
+ libvirt_connect_domain_event_register_any, -1);
3110
+ rb_define_method(c_connect, "domain_event_deregister_any",
3111
+ libvirt_connect_domain_event_deregister_any, 1);
3112
+ #endif
3113
+
3114
+ /* Domain creation/lookup */
3115
+ rb_define_method(c_connect, "num_of_domains",
3116
+ libvirt_connect_num_of_domains, 0);
3117
+ rb_define_method(c_connect, "list_domains", libvirt_connect_list_domains,
3118
+ 0);
3119
+ rb_define_method(c_connect, "num_of_defined_domains",
3120
+ libvirt_connect_num_of_defined_domains, 0);
3121
+ rb_define_method(c_connect, "list_defined_domains",
3122
+ libvirt_connect_list_defined_domains, 0);
3123
+ rb_define_method(c_connect, "create_domain_linux",
3124
+ libvirt_connect_create_linux, -1);
3125
+ #if HAVE_VIRDOMAINCREATEXML
3126
+ rb_define_method(c_connect, "create_domain_xml",
3127
+ libvirt_connect_create_domain_xml, -1);
3128
+ #endif
3129
+ rb_define_method(c_connect, "lookup_domain_by_name",
3130
+ libvirt_connect_lookup_domain_by_name, 1);
3131
+ rb_define_method(c_connect, "lookup_domain_by_id",
3132
+ libvirt_connect_lookup_domain_by_id, 1);
3133
+ rb_define_method(c_connect, "lookup_domain_by_uuid",
3134
+ libvirt_connect_lookup_domain_by_uuid, 1);
3135
+ #if HAVE_CONST_VIR_DOMAIN_DEFINE_VALIDATE
3136
+ rb_define_const(c_connect, "DOMAIN_DEFINE_VALIDATE",
3137
+ INT2NUM(VIR_DOMAIN_DEFINE_VALIDATE));
3138
+ #endif
3139
+ rb_define_method(c_connect, "define_domain_xml",
3140
+ libvirt_connect_define_domain_xml, -1);
3141
+
3142
+ #if HAVE_VIRCONNECTDOMAINXMLFROMNATIVE
3143
+ rb_define_method(c_connect, "domain_xml_from_native",
3144
+ libvirt_connect_domain_xml_from_native, -1);
3145
+ #endif
3146
+ #if HAVE_VIRCONNECTDOMAINXMLTONATIVE
3147
+ rb_define_method(c_connect, "domain_xml_to_native",
3148
+ libvirt_connect_domain_xml_to_native, -1);
3149
+ #endif
3150
+
3151
+ #if HAVE_TYPE_VIRINTERFACEPTR
3152
+ /* Interface lookup/creation methods */
3153
+ rb_define_method(c_connect, "num_of_interfaces",
3154
+ libvirt_connect_num_of_interfaces, 0);
3155
+ rb_define_method(c_connect, "list_interfaces",
3156
+ libvirt_connect_list_interfaces, 0);
3157
+ rb_define_method(c_connect, "num_of_defined_interfaces",
3158
+ libvirt_connect_num_of_defined_interfaces, 0);
3159
+ rb_define_method(c_connect, "list_defined_interfaces",
3160
+ libvirt_connect_list_defined_interfaces, 0);
3161
+ rb_define_method(c_connect, "lookup_interface_by_name",
3162
+ libvirt_connect_lookup_interface_by_name, 1);
3163
+ rb_define_method(c_connect, "lookup_interface_by_mac",
3164
+ libvirt_connect_lookup_interface_by_mac, 1);
3165
+ rb_define_method(c_connect, "define_interface_xml",
3166
+ libvirt_connect_define_interface_xml, -1);
3167
+ #endif
3168
+
3169
+ /* Network lookup/creation methods */
3170
+ rb_define_method(c_connect, "num_of_networks",
3171
+ libvirt_connect_num_of_networks, 0);
3172
+ rb_define_method(c_connect, "list_networks", libvirt_connect_list_networks,
3173
+ 0);
3174
+ rb_define_method(c_connect, "num_of_defined_networks",
3175
+ libvirt_connect_num_of_defined_networks, 0);
3176
+ rb_define_method(c_connect, "list_defined_networks",
3177
+ libvirt_connect_list_defined_networks, 0);
3178
+ rb_define_method(c_connect, "lookup_network_by_name",
3179
+ libvirt_connect_lookup_network_by_name, 1);
3180
+ rb_define_method(c_connect, "lookup_network_by_uuid",
3181
+ libvirt_connect_lookup_network_by_uuid, 1);
3182
+ rb_define_method(c_connect, "create_network_xml",
3183
+ libvirt_connect_create_network_xml, 1);
3184
+ rb_define_method(c_connect, "define_network_xml",
3185
+ libvirt_connect_define_network_xml, 1);
3186
+
3187
+ /* Node device lookup/creation methods */
3188
+ #if HAVE_TYPE_VIRNODEDEVICEPTR
3189
+ rb_define_method(c_connect, "num_of_nodedevices",
3190
+ libvirt_connect_num_of_nodedevices, -1);
3191
+ rb_define_method(c_connect, "list_nodedevices",
3192
+ libvirt_connect_list_nodedevices, -1);
3193
+ rb_define_method(c_connect, "lookup_nodedevice_by_name",
3194
+ libvirt_connect_lookup_nodedevice_by_name, 1);
3195
+ #if HAVE_VIRNODEDEVICECREATEXML
3196
+ rb_define_method(c_connect, "create_nodedevice_xml",
3197
+ libvirt_connect_create_nodedevice_xml, -1);
3198
+ #endif
3199
+ #endif
3200
+
3201
+ #if HAVE_TYPE_VIRNWFILTERPTR
3202
+ /* NWFilter lookup/creation methods */
3203
+ rb_define_method(c_connect, "num_of_nwfilters",
3204
+ libvirt_connect_num_of_nwfilters, 0);
3205
+ rb_define_method(c_connect, "list_nwfilters",
3206
+ libvirt_connect_list_nwfilters, 0);
3207
+ rb_define_method(c_connect, "lookup_nwfilter_by_name",
3208
+ libvirt_connect_lookup_nwfilter_by_name, 1);
3209
+ rb_define_method(c_connect, "lookup_nwfilter_by_uuid",
3210
+ libvirt_connect_lookup_nwfilter_by_uuid, 1);
3211
+ rb_define_method(c_connect, "define_nwfilter_xml",
3212
+ libvirt_connect_define_nwfilter_xml, 1);
3213
+ #endif
3214
+
3215
+ #if HAVE_TYPE_VIRSECRETPTR
3216
+ /* Secret lookup/creation methods */
3217
+ rb_define_method(c_connect, "num_of_secrets",
3218
+ libvirt_connect_num_of_secrets, 0);
3219
+ rb_define_method(c_connect, "list_secrets",
3220
+ libvirt_connect_list_secrets, 0);
3221
+ rb_define_method(c_connect, "lookup_secret_by_uuid",
3222
+ libvirt_connect_lookup_secret_by_uuid, 1);
3223
+ rb_define_method(c_connect, "lookup_secret_by_usage",
3224
+ libvirt_connect_lookup_secret_by_usage, 2);
3225
+ rb_define_method(c_connect, "define_secret_xml",
3226
+ libvirt_connect_define_secret_xml, -1);
3227
+ #endif
3228
+
3229
+ #if HAVE_TYPE_VIRSTORAGEPOOLPTR
3230
+ /* StoragePool lookup/creation methods */
3231
+ rb_define_method(c_connect, "num_of_storage_pools",
3232
+ libvirt_connect_num_of_storage_pools, 0);
3233
+ rb_define_method(c_connect, "list_storage_pools",
3234
+ libvirt_connect_list_storage_pools, 0);
3235
+ rb_define_method(c_connect, "num_of_defined_storage_pools",
3236
+ libvirt_connect_num_of_defined_storage_pools, 0);
3237
+ rb_define_method(c_connect, "list_defined_storage_pools",
3238
+ libvirt_connect_list_defined_storage_pools, 0);
3239
+ rb_define_method(c_connect, "lookup_storage_pool_by_name",
3240
+ libvirt_connect_lookup_pool_by_name, 1);
3241
+ rb_define_method(c_connect, "lookup_storage_pool_by_uuid",
3242
+ libvirt_connect_lookup_pool_by_uuid, 1);
3243
+ rb_define_method(c_connect, "create_storage_pool_xml",
3244
+ libvirt_connect_create_pool_xml, -1);
3245
+ rb_define_method(c_connect, "define_storage_pool_xml",
3246
+ libvirt_connect_define_pool_xml, -1);
3247
+ rb_define_method(c_connect, "discover_storage_pool_sources",
3248
+ libvirt_connect_find_storage_pool_sources, -1);
3249
+ #endif
3250
+
3251
+ #if HAVE_VIRCONNECTGETSYSINFO
3252
+ rb_define_method(c_connect, "sys_info", libvirt_connect_sys_info, -1);
3253
+ #endif
3254
+ #if HAVE_TYPE_VIRSTREAMPTR
3255
+ rb_define_method(c_connect, "stream", libvirt_connect_stream, -1);
3256
+ #endif
3257
+
3258
+ #if HAVE_VIRINTERFACECHANGEBEGIN
3259
+ rb_define_method(c_connect, "interface_change_begin",
3260
+ libvirt_connect_interface_change_begin, -1);
3261
+ rb_define_method(c_connect, "interface_change_commit",
3262
+ libvirt_connect_interface_change_commit, -1);
3263
+ rb_define_method(c_connect, "interface_change_rollback",
3264
+ libvirt_connect_interface_change_rollback, -1);
3265
+ #endif
3266
+
3267
+ #if HAVE_VIRNODEGETCPUSTATS
3268
+ rb_define_method(c_connect, "node_cpu_stats",
3269
+ libvirt_connect_node_cpu_stats, -1);
3270
+ #endif
3271
+ #if HAVE_CONST_VIR_NODE_CPU_STATS_ALL_CPUS
3272
+ rb_define_const(c_connect, "NODE_CPU_STATS_ALL_CPUS",
3273
+ INT2NUM(VIR_NODE_CPU_STATS_ALL_CPUS));
3274
+ #endif
3275
+ #if HAVE_VIRNODEGETMEMORYSTATS
3276
+ rb_define_method(c_connect, "node_memory_stats",
3277
+ libvirt_connect_node_memory_stats, -1);
3278
+ #endif
3279
+ #if HAVE_CONST_VIR_NODE_MEMORY_STATS_ALL_CELLS
3280
+ rb_define_const(c_connect, "NODE_MEMORY_STATS_ALL_CELLS",
3281
+ INT2NUM(VIR_NODE_MEMORY_STATS_ALL_CELLS));
3282
+ #endif
3283
+
3284
+ #if HAVE_VIRDOMAINSAVEIMAGEGETXMLDESC
3285
+ rb_define_method(c_connect, "save_image_xml_desc",
3286
+ libvirt_connect_save_image_xml_desc, -1);
3287
+ rb_define_method(c_connect, "define_save_image_xml",
3288
+ libvirt_connect_define_save_image_xml, -1);
3289
+ #endif
3290
+
3291
+ #if HAVE_VIRNODESUSPENDFORDURATION
3292
+ rb_define_const(c_connect, "NODE_SUSPEND_TARGET_MEM",
3293
+ INT2NUM(VIR_NODE_SUSPEND_TARGET_MEM));
3294
+ rb_define_const(c_connect, "NODE_SUSPEND_TARGET_DISK",
3295
+ INT2NUM(VIR_NODE_SUSPEND_TARGET_DISK));
3296
+ rb_define_const(c_connect, "NODE_SUSPEND_TARGET_HYBRID",
3297
+ INT2NUM(VIR_NODE_SUSPEND_TARGET_HYBRID));
3298
+
3299
+ rb_define_method(c_connect, "node_suspend_for_duration",
3300
+ libvirt_connect_node_suspend_for_duration, -1);
3301
+ #endif
3302
+
3303
+ #if HAVE_VIRNODEGETMEMORYPARAMETERS
3304
+ rb_define_method(c_connect, "node_memory_parameters",
3305
+ libvirt_connect_node_memory_parameters, -1);
3306
+ rb_define_method(c_connect, "node_memory_parameters=",
3307
+ libvirt_connect_node_memory_parameters_equal, 1);
3308
+ #endif
3309
+
3310
+ #if HAVE_VIRNODEGETCPUMAP
3311
+ rb_define_method(c_connect, "node_cpu_map",
3312
+ libvirt_connect_node_cpu_map, -1);
3313
+ rb_define_alias(c_connect, "node_get_cpu_map", "node_cpu_map");
3314
+ #endif
3315
+
3316
+ #if HAVE_VIRCONNECTSETKEEPALIVE
3317
+ rb_define_method(c_connect, "set_keepalive",
3318
+ libvirt_connect_set_keepalive, 2);
3319
+ rb_define_method(c_connect, "keepalive=", libvirt_connect_keepalive_equal,
3320
+ 1);
3321
+ #endif
3322
+
3323
+ #if HAVE_VIRCONNECTLISTALLDOMAINS
3324
+ rb_define_const(c_connect, "LIST_DOMAINS_ACTIVE",
3325
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_ACTIVE));
3326
+ rb_define_const(c_connect, "LIST_DOMAINS_INACTIVE",
3327
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_INACTIVE));
3328
+ rb_define_const(c_connect, "LIST_DOMAINS_PERSISTENT",
3329
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_PERSISTENT));
3330
+ rb_define_const(c_connect, "LIST_DOMAINS_TRANSIENT",
3331
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_TRANSIENT));
3332
+ rb_define_const(c_connect, "LIST_DOMAINS_RUNNING",
3333
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_RUNNING));
3334
+ rb_define_const(c_connect, "LIST_DOMAINS_PAUSED",
3335
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_PAUSED));
3336
+ rb_define_const(c_connect, "LIST_DOMAINS_SHUTOFF",
3337
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_SHUTOFF));
3338
+ rb_define_const(c_connect, "LIST_DOMAINS_OTHER",
3339
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_OTHER));
3340
+ rb_define_const(c_connect, "LIST_DOMAINS_MANAGEDSAVE",
3341
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE));
3342
+ rb_define_const(c_connect, "LIST_DOMAINS_NO_MANAGEDSAVE",
3343
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE));
3344
+ rb_define_const(c_connect, "LIST_DOMAINS_AUTOSTART",
3345
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_AUTOSTART));
3346
+ rb_define_const(c_connect, "LIST_DOMAINS_NO_AUTOSTART",
3347
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART));
3348
+ rb_define_const(c_connect, "LIST_DOMAINS_HAS_SNAPSHOT",
3349
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT));
3350
+ rb_define_const(c_connect, "LIST_DOMAINS_NO_SNAPSHOT",
3351
+ INT2NUM(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT));
3352
+ rb_define_method(c_connect, "list_all_domains",
3353
+ libvirt_connect_list_all_domains, -1);
3354
+ #endif
3355
+ #if HAVE_VIRCONNECTLISTALLNETWORKS
3356
+ rb_define_const(c_connect, "LIST_NETWORKS_ACTIVE",
3357
+ INT2NUM(VIR_CONNECT_LIST_NETWORKS_ACTIVE));
3358
+ rb_define_const(c_connect, "LIST_NETWORKS_INACTIVE",
3359
+ INT2NUM(VIR_CONNECT_LIST_NETWORKS_INACTIVE));
3360
+ rb_define_const(c_connect, "LIST_NETWORKS_PERSISTENT",
3361
+ INT2NUM(VIR_CONNECT_LIST_NETWORKS_PERSISTENT));
3362
+ rb_define_const(c_connect, "LIST_NETWORKS_TRANSIENT",
3363
+ INT2NUM(VIR_CONNECT_LIST_NETWORKS_TRANSIENT));
3364
+ rb_define_const(c_connect, "LIST_NETWORKS_AUTOSTART",
3365
+ INT2NUM(VIR_CONNECT_LIST_NETWORKS_AUTOSTART));
3366
+ rb_define_const(c_connect, "LIST_NETWORKS_NO_AUTOSTART",
3367
+ INT2NUM(VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART));
3368
+ rb_define_method(c_connect, "list_all_networks",
3369
+ libvirt_connect_list_all_networks, -1);
3370
+ #endif
3371
+ #if HAVE_VIRCONNECTLISTALLINTERFACES
3372
+ rb_define_const(c_connect, "LIST_INTERFACES_INACTIVE",
3373
+ INT2NUM(VIR_CONNECT_LIST_INTERFACES_INACTIVE));
3374
+ rb_define_const(c_connect, "LIST_INTERFACES_ACTIVE",
3375
+ INT2NUM(VIR_CONNECT_LIST_INTERFACES_ACTIVE));
3376
+ rb_define_method(c_connect, "list_all_interfaces",
3377
+ libvirt_connect_list_all_interfaces, -1);
3378
+ #endif
3379
+ #if HAVE_VIRCONNECTLISTALLSECRETS
3380
+ rb_define_const(c_connect, "LIST_SECRETS_EPHEMERAL",
3381
+ INT2NUM(VIR_CONNECT_LIST_SECRETS_EPHEMERAL));
3382
+ rb_define_const(c_connect, "LIST_SECRETS_NO_EPHEMERAL",
3383
+ INT2NUM(VIR_CONNECT_LIST_SECRETS_NO_EPHEMERAL));
3384
+ rb_define_const(c_connect, "LIST_SECRETS_PRIVATE",
3385
+ INT2NUM(VIR_CONNECT_LIST_SECRETS_PRIVATE));
3386
+ rb_define_const(c_connect, "LIST_SECRETS_NO_PRIVATE",
3387
+ INT2NUM(VIR_CONNECT_LIST_SECRETS_NO_PRIVATE));
3388
+ rb_define_method(c_connect, "list_all_secrets",
3389
+ libvirt_connect_list_all_secrets, -1);
3390
+ #endif
3391
+ #if HAVE_VIRCONNECTLISTALLNODEDEVICES
3392
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SYSTEM",
3393
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SYSTEM));
3394
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_PCI_DEV",
3395
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV));
3396
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_USB_DEV",
3397
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_DEV));
3398
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_USB_INTERFACE",
3399
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_USB_INTERFACE));
3400
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_NET",
3401
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_NET));
3402
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI_HOST",
3403
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_HOST));
3404
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI_TARGET",
3405
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_TARGET));
3406
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI",
3407
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI));
3408
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_STORAGE",
3409
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_STORAGE));
3410
+ #if HAVE_CONST_VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST
3411
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_FC_HOST",
3412
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_FC_HOST));
3413
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_VPORTS",
3414
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_VPORTS));
3415
+ #endif
3416
+ #if HAVE_CONST_VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC
3417
+ rb_define_const(c_connect, "LIST_NODE_DEVICES_CAP_SCSI_GENERIC",
3418
+ INT2NUM(VIR_CONNECT_LIST_NODE_DEVICES_CAP_SCSI_GENERIC));
3419
+ #endif
3420
+ rb_define_method(c_connect, "list_all_nodedevices",
3421
+ libvirt_connect_list_all_nodedevices, -1);
3422
+ #endif
3423
+ #if HAVE_VIRCONNECTLISTALLSTORAGEPOOLS
3424
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_INACTIVE",
3425
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE));
3426
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_ACTIVE",
3427
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE));
3428
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_PERSISTENT",
3429
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT));
3430
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_TRANSIENT",
3431
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT));
3432
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_AUTOSTART",
3433
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART));
3434
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_NO_AUTOSTART",
3435
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART));
3436
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_DIR",
3437
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_DIR));
3438
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_FS",
3439
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_FS));
3440
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_NETFS",
3441
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_NETFS));
3442
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_LOGICAL",
3443
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL));
3444
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_DISK",
3445
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_DISK));
3446
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_ISCSI",
3447
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI));
3448
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_SCSI",
3449
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_SCSI));
3450
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_MPATH",
3451
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_MPATH));
3452
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_RBD",
3453
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_RBD));
3454
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_SHEEPDOG",
3455
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG));
3456
+ rb_define_method(c_connect, "list_all_storage_pools",
3457
+ libvirt_connect_list_all_storage_pools, -1);
3458
+ #endif
3459
+ #if HAVE_CONST_VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER
3460
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_GLUSTER",
3461
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER));
3462
+ #endif
3463
+ #if HAVE_CONST_VIR_CONNECT_LIST_STORAGE_POOLS_ZFS
3464
+ rb_define_const(c_connect, "LIST_STORAGE_POOLS_ZFS",
3465
+ INT2NUM(VIR_CONNECT_LIST_STORAGE_POOLS_ZFS));
3466
+ #endif
3467
+ #if HAVE_VIRCONNECTLISTALLNWFILTERS
3468
+ rb_define_method(c_connect, "list_all_nwfilters",
3469
+ libvirt_connect_list_all_nwfilters, -1);
3470
+ #endif
3471
+ #if HAVE_VIRCONNECTISALIVE
3472
+ rb_define_method(c_connect, "alive?", libvirt_connect_alive_p, 0);
3473
+ #endif
3474
+ #if HAVE_VIRDOMAINCREATEXMLWITHFILES
3475
+ rb_define_method(c_connect, "create_domain_xml_with_files",
3476
+ libvirt_connect_create_domain_xml_with_files, -1);
3477
+ #endif
3478
+ #if HAVE_VIRDOMAINQEMUATTACH
3479
+ rb_define_method(c_connect, "qemu_attach", libvirt_connect_qemu_attach, -1);
3480
+ #endif
3481
+ #if HAVE_VIRCONNECTGETCPUMODELNAMES
3482
+ rb_define_method(c_connect, "cpu_model_names",
3483
+ libvirt_connect_cpu_model_names, -1);
3484
+ #endif
3485
+ #if HAVE_VIRNODEALLOCPAGES
3486
+ rb_define_const(c_connect, "NODE_ALLOC_PAGES_ADD",
3487
+ INT2NUM(VIR_NODE_ALLOC_PAGES_ADD));
3488
+ rb_define_const(c_connect, "NODE_ALLOC_PAGES_SET",
3489
+ INT2NUM(VIR_NODE_ALLOC_PAGES_SET));
3490
+ rb_define_method(c_connect, "node_alloc_pages",
3491
+ libvirt_connect_node_alloc_pages, -1);
3492
+ #endif
3493
+ #if HAVE_VIRCONNECTGETDOMAINCAPABILITIES
3494
+ rb_define_method(c_connect, "domain_capabilities",
3495
+ libvirt_connect_domain_capabilities, -1);
3496
+ #endif
3497
+ #if HAVE_VIRNODEGETFREEPAGES
3498
+ rb_define_method(c_connect, "node_free_pages",
3499
+ libvirt_connect_node_free_pages, -1);
3500
+ #endif
3501
+ }