« back to all changes in this revision
Viewing changes to python/libvirt.c
- browse files at revision 0.2.7
- compare with another revision
- compare with revision 0.2.7
- download diff
- download tarball
- view history from revision 0.2.7
- Committer: Bazaar Package Importer
- Author(s): Guido Günther
- Date: 2010-05-09 14:25:00 UTC
- mto: (1.2.5 upstream) (3.4.15 squeeze)
- mto: This revision was merged to the branch mainline in revision 92.
- Revision ID: james.westby@ubuntu.com-20100509142500-1aracjxxmac2zx33
Import upstream version 0.8.1
- files added:
- .x-sc_prohibit_gettext_noop
- files removed:
- python/libvirt.c
- files modified:
- AUTHORS
added
removed
python/libvirt.c
1
/* Generated */
2
3
#include <Python.h>
4
#include <libvirt/libvirt.h>
5
#include "typewrappers.h"
6
#include "libvirt.h"
7
8
PyObject *
9
libvirt_virStoragePoolGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10
PyObject *py_retval;
11
char * c_retval;
12
virStoragePoolPtr pool;
13
PyObject *pyobj_pool;
14
unsigned int flags;
15
16
if (!PyArg_ParseTuple(args, (char *)"Oi:virStoragePoolGetXMLDesc", &pyobj_pool, &flags))
17
return(NULL);
18
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
19
LIBVIRT_BEGIN_ALLOW_THREADS;
20
21
c_retval = virStoragePoolGetXMLDesc(pool, flags);
22
LIBVIRT_END_ALLOW_THREADS;
23
py_retval = libvirt_charPtrWrap((char *) c_retval);
24
return(py_retval);
25
}
26
27
PyObject *
28
libvirt_virStorageVolGetKey(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
29
PyObject *py_retval;
30
const char * c_retval;
31
virStorageVolPtr vol;
32
PyObject *pyobj_vol;
33
34
if (!PyArg_ParseTuple(args, (char *)"O:virStorageVolGetKey", &pyobj_vol))
35
return(NULL);
36
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
37
LIBVIRT_BEGIN_ALLOW_THREADS;
38
39
c_retval = virStorageVolGetKey(vol);
40
LIBVIRT_END_ALLOW_THREADS;
41
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
42
return(py_retval);
43
}
44
45
PyObject *
46
libvirt_virDomainUndefine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
47
PyObject *py_retval;
48
int c_retval;
49
virDomainPtr domain;
50
PyObject *pyobj_domain;
51
52
if (!PyArg_ParseTuple(args, (char *)"O:virDomainUndefine", &pyobj_domain))
53
return(NULL);
54
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
55
LIBVIRT_BEGIN_ALLOW_THREADS;
56
57
c_retval = virDomainUndefine(domain);
58
LIBVIRT_END_ALLOW_THREADS;
59
py_retval = libvirt_intWrap((int) c_retval);
60
return(py_retval);
61
}
62
63
PyObject *
64
libvirt_virDomainDefineXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
65
PyObject *py_retval;
66
virDomainPtr c_retval;
67
virConnectPtr conn;
68
PyObject *pyobj_conn;
69
char * xml;
70
71
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainDefineXML", &pyobj_conn, &xml))
72
return(NULL);
73
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
74
LIBVIRT_BEGIN_ALLOW_THREADS;
75
76
c_retval = virDomainDefineXML(conn, xml);
77
LIBVIRT_END_ALLOW_THREADS;
78
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
79
return(py_retval);
80
}
81
82
PyObject *
83
libvirt_virDomainShutdown(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
84
PyObject *py_retval;
85
int c_retval;
86
virDomainPtr domain;
87
PyObject *pyobj_domain;
88
89
if (!PyArg_ParseTuple(args, (char *)"O:virDomainShutdown", &pyobj_domain))
90
return(NULL);
91
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
92
LIBVIRT_BEGIN_ALLOW_THREADS;
93
94
c_retval = virDomainShutdown(domain);
95
LIBVIRT_END_ALLOW_THREADS;
96
py_retval = libvirt_intWrap((int) c_retval);
97
return(py_retval);
98
}
99
100
PyObject *
101
libvirt_virStorageVolWipe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
102
PyObject *py_retval;
103
int c_retval;
104
virStorageVolPtr vol;
105
PyObject *pyobj_vol;
106
unsigned int flags;
107
108
if (!PyArg_ParseTuple(args, (char *)"Oi:virStorageVolWipe", &pyobj_vol, &flags))
109
return(NULL);
110
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
111
LIBVIRT_BEGIN_ALLOW_THREADS;
112
113
c_retval = virStorageVolWipe(vol, flags);
114
LIBVIRT_END_ALLOW_THREADS;
115
py_retval = libvirt_intWrap((int) c_retval);
116
return(py_retval);
117
}
118
119
PyObject *
120
libvirt_virDomainAbortJob(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
121
PyObject *py_retval;
122
int c_retval;
123
virDomainPtr domain;
124
PyObject *pyobj_domain;
125
126
if (!PyArg_ParseTuple(args, (char *)"O:virDomainAbortJob", &pyobj_domain))
127
return(NULL);
128
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
129
LIBVIRT_BEGIN_ALLOW_THREADS;
130
131
c_retval = virDomainAbortJob(domain);
132
LIBVIRT_END_ALLOW_THREADS;
133
py_retval = libvirt_intWrap((int) c_retval);
134
return(py_retval);
135
}
136
137
PyObject *
138
libvirt_virNodeDeviceGetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
139
PyObject *py_retval;
140
const char * c_retval;
141
virNodeDevicePtr dev;
142
PyObject *pyobj_dev;
143
144
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceGetName", &pyobj_dev))
145
return(NULL);
146
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
147
LIBVIRT_BEGIN_ALLOW_THREADS;
148
149
c_retval = virNodeDeviceGetName(dev);
150
LIBVIRT_END_ALLOW_THREADS;
151
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
152
return(py_retval);
153
}
154
155
PyObject *
156
libvirt_virConnectNumOfSecrets(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
157
PyObject *py_retval;
158
int c_retval;
159
virConnectPtr conn;
160
PyObject *pyobj_conn;
161
162
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfSecrets", &pyobj_conn))
163
return(NULL);
164
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
165
LIBVIRT_BEGIN_ALLOW_THREADS;
166
167
c_retval = virConnectNumOfSecrets(conn);
168
LIBVIRT_END_ALLOW_THREADS;
169
py_retval = libvirt_intWrap((int) c_retval);
170
return(py_retval);
171
}
172
173
PyObject *
174
libvirt_virStoragePoolSetAutostart(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
175
PyObject *py_retval;
176
int c_retval;
177
virStoragePoolPtr pool;
178
PyObject *pyobj_pool;
179
int autostart;
180
181
if (!PyArg_ParseTuple(args, (char *)"Oi:virStoragePoolSetAutostart", &pyobj_pool, &autostart))
182
return(NULL);
183
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
184
LIBVIRT_BEGIN_ALLOW_THREADS;
185
186
c_retval = virStoragePoolSetAutostart(pool, autostart);
187
LIBVIRT_END_ALLOW_THREADS;
188
py_retval = libvirt_intWrap((int) c_retval);
189
return(py_retval);
190
}
191
192
PyObject *
193
libvirt_virConnectDomainXMLFromNative(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
194
PyObject *py_retval;
195
char * c_retval;
196
virConnectPtr conn;
197
PyObject *pyobj_conn;
198
char * nativeFormat;
199
char * nativeConfig;
200
unsigned int flags;
201
202
if (!PyArg_ParseTuple(args, (char *)"Ozzi:virConnectDomainXMLFromNative", &pyobj_conn, &nativeFormat, &nativeConfig, &flags))
203
return(NULL);
204
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
205
LIBVIRT_BEGIN_ALLOW_THREADS;
206
207
c_retval = virConnectDomainXMLFromNative(conn, nativeFormat, nativeConfig, flags);
208
LIBVIRT_END_ALLOW_THREADS;
209
py_retval = libvirt_charPtrWrap((char *) c_retval);
210
return(py_retval);
211
}
212
213
PyObject *
214
libvirt_virNodeDeviceDettach(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
215
PyObject *py_retval;
216
int c_retval;
217
virNodeDevicePtr dev;
218
PyObject *pyobj_dev;
219
220
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceDettach", &pyobj_dev))
221
return(NULL);
222
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
223
LIBVIRT_BEGIN_ALLOW_THREADS;
224
225
c_retval = virNodeDeviceDettach(dev);
226
LIBVIRT_END_ALLOW_THREADS;
227
py_retval = libvirt_intWrap((int) c_retval);
228
return(py_retval);
229
}
230
231
PyObject *
232
libvirt_virDomainLookupByUUIDString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
233
PyObject *py_retval;
234
virDomainPtr c_retval;
235
virConnectPtr conn;
236
PyObject *pyobj_conn;
237
char * uuidstr;
238
239
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainLookupByUUIDString", &pyobj_conn, &uuidstr))
240
return(NULL);
241
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
242
LIBVIRT_BEGIN_ALLOW_THREADS;
243
244
c_retval = virDomainLookupByUUIDString(conn, uuidstr);
245
LIBVIRT_END_ALLOW_THREADS;
246
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
247
return(py_retval);
248
}
249
250
PyObject *
251
libvirt_virConnectNumOfDefinedNetworks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
252
PyObject *py_retval;
253
int c_retval;
254
virConnectPtr conn;
255
PyObject *pyobj_conn;
256
257
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfDefinedNetworks", &pyobj_conn))
258
return(NULL);
259
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
260
LIBVIRT_BEGIN_ALLOW_THREADS;
261
262
c_retval = virConnectNumOfDefinedNetworks(conn);
263
LIBVIRT_END_ALLOW_THREADS;
264
py_retval = libvirt_intWrap((int) c_retval);
265
return(py_retval);
266
}
267
268
PyObject *
269
libvirt_virStoragePoolIsActive(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
270
PyObject *py_retval;
271
int c_retval;
272
virStoragePoolPtr pool;
273
PyObject *pyobj_pool;
274
275
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolIsActive", &pyobj_pool))
276
return(NULL);
277
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
278
LIBVIRT_BEGIN_ALLOW_THREADS;
279
280
c_retval = virStoragePoolIsActive(pool);
281
LIBVIRT_END_ALLOW_THREADS;
282
py_retval = libvirt_intWrap((int) c_retval);
283
return(py_retval);
284
}
285
286
PyObject *
287
libvirt_virInterfaceGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
288
PyObject *py_retval;
289
char * c_retval;
290
virInterfacePtr iface;
291
PyObject *pyobj_iface;
292
unsigned int flags;
293
294
if (!PyArg_ParseTuple(args, (char *)"Oi:virInterfaceGetXMLDesc", &pyobj_iface, &flags))
295
return(NULL);
296
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
297
LIBVIRT_BEGIN_ALLOW_THREADS;
298
299
c_retval = virInterfaceGetXMLDesc(iface, flags);
300
LIBVIRT_END_ALLOW_THREADS;
301
py_retval = libvirt_charPtrWrap((char *) c_retval);
302
return(py_retval);
303
}
304
305
PyObject *
306
libvirt_virDomainFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
307
PyObject *py_retval;
308
int c_retval;
309
virDomainPtr domain;
310
PyObject *pyobj_domain;
311
312
if (!PyArg_ParseTuple(args, (char *)"O:virDomainFree", &pyobj_domain))
313
return(NULL);
314
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
315
LIBVIRT_BEGIN_ALLOW_THREADS;
316
317
c_retval = virDomainFree(domain);
318
LIBVIRT_END_ALLOW_THREADS;
319
py_retval = libvirt_intWrap((int) c_retval);
320
return(py_retval);
321
}
322
323
PyObject *
324
libvirt_virStoragePoolGetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
325
PyObject *py_retval;
326
const char * c_retval;
327
virStoragePoolPtr pool;
328
PyObject *pyobj_pool;
329
330
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetName", &pyobj_pool))
331
return(NULL);
332
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
333
LIBVIRT_BEGIN_ALLOW_THREADS;
334
335
c_retval = virStoragePoolGetName(pool);
336
LIBVIRT_END_ALLOW_THREADS;
337
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
338
return(py_retval);
339
}
340
341
PyObject *
342
libvirt_virConnectGetMaxVcpus(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
343
PyObject *py_retval;
344
int c_retval;
345
virConnectPtr conn;
346
PyObject *pyobj_conn;
347
char * type;
348
349
if (!PyArg_ParseTuple(args, (char *)"Oz:virConnectGetMaxVcpus", &pyobj_conn, &type))
350
return(NULL);
351
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
352
LIBVIRT_BEGIN_ALLOW_THREADS;
353
354
c_retval = virConnectGetMaxVcpus(conn, type);
355
LIBVIRT_END_ALLOW_THREADS;
356
py_retval = libvirt_intWrap((int) c_retval);
357
return(py_retval);
358
}
359
360
PyObject *
361
libvirt_virStoragePoolDefineXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
362
PyObject *py_retval;
363
virStoragePoolPtr c_retval;
364
virConnectPtr conn;
365
PyObject *pyobj_conn;
366
char * xml;
367
unsigned int flags;
368
369
if (!PyArg_ParseTuple(args, (char *)"Ozi:virStoragePoolDefineXML", &pyobj_conn, &xml, &flags))
370
return(NULL);
371
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
372
LIBVIRT_BEGIN_ALLOW_THREADS;
373
374
c_retval = virStoragePoolDefineXML(conn, xml, flags);
375
LIBVIRT_END_ALLOW_THREADS;
376
py_retval = libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
377
return(py_retval);
378
}
379
380
PyObject *
381
libvirt_virStorageVolLookupByPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
382
PyObject *py_retval;
383
virStorageVolPtr c_retval;
384
virConnectPtr conn;
385
PyObject *pyobj_conn;
386
char * path;
387
388
if (!PyArg_ParseTuple(args, (char *)"Oz:virStorageVolLookupByPath", &pyobj_conn, &path))
389
return(NULL);
390
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
391
LIBVIRT_BEGIN_ALLOW_THREADS;
392
393
c_retval = virStorageVolLookupByPath(conn, path);
394
LIBVIRT_END_ALLOW_THREADS;
395
py_retval = libvirt_virStorageVolPtrWrap((virStorageVolPtr) c_retval);
396
return(py_retval);
397
}
398
399
PyObject *
400
libvirt_virStorageVolLookupByName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
401
PyObject *py_retval;
402
virStorageVolPtr c_retval;
403
virStoragePoolPtr pool;
404
PyObject *pyobj_pool;
405
char * name;
406
407
if (!PyArg_ParseTuple(args, (char *)"Oz:virStorageVolLookupByName", &pyobj_pool, &name))
408
return(NULL);
409
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
410
LIBVIRT_BEGIN_ALLOW_THREADS;
411
412
c_retval = virStorageVolLookupByName(pool, name);
413
LIBVIRT_END_ALLOW_THREADS;
414
py_retval = libvirt_virStorageVolPtrWrap((virStorageVolPtr) c_retval);
415
return(py_retval);
416
}
417
418
PyObject *
419
libvirt_virNetworkCreate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
420
PyObject *py_retval;
421
int c_retval;
422
virNetworkPtr network;
423
PyObject *pyobj_network;
424
425
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkCreate", &pyobj_network))
426
return(NULL);
427
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
428
LIBVIRT_BEGIN_ALLOW_THREADS;
429
430
c_retval = virNetworkCreate(network);
431
LIBVIRT_END_ALLOW_THREADS;
432
py_retval = libvirt_intWrap((int) c_retval);
433
return(py_retval);
434
}
435
436
PyObject *
437
libvirt_virInterfaceDefineXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
438
PyObject *py_retval;
439
virInterfacePtr c_retval;
440
virConnectPtr conn;
441
PyObject *pyobj_conn;
442
char * xml;
443
unsigned int flags;
444
445
if (!PyArg_ParseTuple(args, (char *)"Ozi:virInterfaceDefineXML", &pyobj_conn, &xml, &flags))
446
return(NULL);
447
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
448
LIBVIRT_BEGIN_ALLOW_THREADS;
449
450
c_retval = virInterfaceDefineXML(conn, xml, flags);
451
LIBVIRT_END_ALLOW_THREADS;
452
py_retval = libvirt_virInterfacePtrWrap((virInterfacePtr) c_retval);
453
return(py_retval);
454
}
455
456
PyObject *
457
libvirt_virDomainSuspend(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
458
PyObject *py_retval;
459
int c_retval;
460
virDomainPtr domain;
461
PyObject *pyobj_domain;
462
463
if (!PyArg_ParseTuple(args, (char *)"O:virDomainSuspend", &pyobj_domain))
464
return(NULL);
465
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
466
LIBVIRT_BEGIN_ALLOW_THREADS;
467
468
c_retval = virDomainSuspend(domain);
469
LIBVIRT_END_ALLOW_THREADS;
470
py_retval = libvirt_intWrap((int) c_retval);
471
return(py_retval);
472
}
473
474
PyObject *
475
libvirt_virDomainCreateLinux(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
476
PyObject *py_retval;
477
virDomainPtr c_retval;
478
virConnectPtr conn;
479
PyObject *pyobj_conn;
480
char * xmlDesc;
481
unsigned int flags;
482
483
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainCreateLinux", &pyobj_conn, &xmlDesc, &flags))
484
return(NULL);
485
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
486
LIBVIRT_BEGIN_ALLOW_THREADS;
487
488
c_retval = virDomainCreateLinux(conn, xmlDesc, flags);
489
LIBVIRT_END_ALLOW_THREADS;
490
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
491
return(py_retval);
492
}
493
494
PyObject *
495
libvirt_virNodeDeviceGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
496
PyObject *py_retval;
497
char * c_retval;
498
virNodeDevicePtr dev;
499
PyObject *pyobj_dev;
500
unsigned int flags;
501
502
if (!PyArg_ParseTuple(args, (char *)"Oi:virNodeDeviceGetXMLDesc", &pyobj_dev, &flags))
503
return(NULL);
504
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
505
LIBVIRT_BEGIN_ALLOW_THREADS;
506
507
c_retval = virNodeDeviceGetXMLDesc(dev, flags);
508
LIBVIRT_END_ALLOW_THREADS;
509
py_retval = libvirt_charPtrWrap((char *) c_retval);
510
return(py_retval);
511
}
512
513
PyObject *
514
libvirt_virDomainDestroy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
515
PyObject *py_retval;
516
int c_retval;
517
virDomainPtr domain;
518
PyObject *pyobj_domain;
519
520
if (!PyArg_ParseTuple(args, (char *)"O:virDomainDestroy", &pyobj_domain))
521
return(NULL);
522
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
523
LIBVIRT_BEGIN_ALLOW_THREADS;
524
525
c_retval = virDomainDestroy(domain);
526
LIBVIRT_END_ALLOW_THREADS;
527
py_retval = libvirt_intWrap((int) c_retval);
528
return(py_retval);
529
}
530
531
PyObject *
532
libvirt_virConnectNumOfNetworks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
533
PyObject *py_retval;
534
int c_retval;
535
virConnectPtr conn;
536
PyObject *pyobj_conn;
537
538
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfNetworks", &pyobj_conn))
539
return(NULL);
540
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
541
LIBVIRT_BEGIN_ALLOW_THREADS;
542
543
c_retval = virConnectNumOfNetworks(conn);
544
LIBVIRT_END_ALLOW_THREADS;
545
py_retval = libvirt_intWrap((int) c_retval);
546
return(py_retval);
547
}
548
549
PyObject *
550
libvirt_virStorageVolGetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
551
PyObject *py_retval;
552
const char * c_retval;
553
virStorageVolPtr vol;
554
PyObject *pyobj_vol;
555
556
if (!PyArg_ParseTuple(args, (char *)"O:virStorageVolGetName", &pyobj_vol))
557
return(NULL);
558
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
559
LIBVIRT_BEGIN_ALLOW_THREADS;
560
561
c_retval = virStorageVolGetName(vol);
562
LIBVIRT_END_ALLOW_THREADS;
563
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
564
return(py_retval);
565
}
566
567
PyObject *
568
libvirt_virStoragePoolLookupByUUIDString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
569
PyObject *py_retval;
570
virStoragePoolPtr c_retval;
571
virConnectPtr conn;
572
PyObject *pyobj_conn;
573
char * uuidstr;
574
575
if (!PyArg_ParseTuple(args, (char *)"Oz:virStoragePoolLookupByUUIDString", &pyobj_conn, &uuidstr))
576
return(NULL);
577
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
578
LIBVIRT_BEGIN_ALLOW_THREADS;
579
580
c_retval = virStoragePoolLookupByUUIDString(conn, uuidstr);
581
LIBVIRT_END_ALLOW_THREADS;
582
py_retval = libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
583
return(py_retval);
584
}
585
586
PyObject *
587
libvirt_virInterfaceCreate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
588
PyObject *py_retval;
589
int c_retval;
590
virInterfacePtr iface;
591
PyObject *pyobj_iface;
592
unsigned int flags;
593
594
if (!PyArg_ParseTuple(args, (char *)"Oi:virInterfaceCreate", &pyobj_iface, &flags))
595
return(NULL);
596
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
597
LIBVIRT_BEGIN_ALLOW_THREADS;
598
599
c_retval = virInterfaceCreate(iface, flags);
600
LIBVIRT_END_ALLOW_THREADS;
601
py_retval = libvirt_intWrap((int) c_retval);
602
return(py_retval);
603
}
604
605
PyObject *
606
libvirt_virDomainGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
607
PyObject *py_retval;
608
char * c_retval;
609
virDomainPtr domain;
610
PyObject *pyobj_domain;
611
int flags;
612
613
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainGetXMLDesc", &pyobj_domain, &flags))
614
return(NULL);
615
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
616
LIBVIRT_BEGIN_ALLOW_THREADS;
617
618
c_retval = virDomainGetXMLDesc(domain, flags);
619
LIBVIRT_END_ALLOW_THREADS;
620
py_retval = libvirt_charPtrWrap((char *) c_retval);
621
return(py_retval);
622
}
623
624
PyObject *
625
libvirt_virSecretLookupByUsage(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
626
PyObject *py_retval;
627
virSecretPtr c_retval;
628
virConnectPtr conn;
629
PyObject *pyobj_conn;
630
int usageType;
631
char * usageID;
632
633
if (!PyArg_ParseTuple(args, (char *)"Oiz:virSecretLookupByUsage", &pyobj_conn, &usageType, &usageID))
634
return(NULL);
635
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
636
LIBVIRT_BEGIN_ALLOW_THREADS;
637
638
c_retval = virSecretLookupByUsage(conn, usageType, usageID);
639
LIBVIRT_END_ALLOW_THREADS;
640
py_retval = libvirt_virSecretPtrWrap((virSecretPtr) c_retval);
641
return(py_retval);
642
}
643
644
PyObject *
645
libvirt_virConnectCompareCPU(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
646
PyObject *py_retval;
647
int c_retval;
648
virConnectPtr conn;
649
PyObject *pyobj_conn;
650
char * xmlDesc;
651
unsigned int flags;
652
653
if (!PyArg_ParseTuple(args, (char *)"Ozi:virConnectCompareCPU", &pyobj_conn, &xmlDesc, &flags))
654
return(NULL);
655
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
656
LIBVIRT_BEGIN_ALLOW_THREADS;
657
658
c_retval = virConnectCompareCPU(conn, xmlDesc, flags);
659
LIBVIRT_END_ALLOW_THREADS;
660
py_retval = libvirt_intWrap((int) c_retval);
661
return(py_retval);
662
}
663
664
PyObject *
665
libvirt_virDomainMigrateSetMaxDowntime(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
666
PyObject *py_retval;
667
int c_retval;
668
virDomainPtr domain;
669
PyObject *pyobj_domain;
670
unsigned long long downtime;
671
unsigned int flags;
672
673
if (!PyArg_ParseTuple(args, (char *)"Oli:virDomainMigrateSetMaxDowntime", &pyobj_domain, &downtime, &flags))
674
return(NULL);
675
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
676
LIBVIRT_BEGIN_ALLOW_THREADS;
677
678
c_retval = virDomainMigrateSetMaxDowntime(domain, downtime, flags);
679
LIBVIRT_END_ALLOW_THREADS;
680
py_retval = libvirt_intWrap((int) c_retval);
681
return(py_retval);
682
}
683
684
PyObject *
685
libvirt_virNodeDeviceFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
686
PyObject *py_retval;
687
int c_retval;
688
virNodeDevicePtr dev;
689
PyObject *pyobj_dev;
690
691
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceFree", &pyobj_dev))
692
return(NULL);
693
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
694
LIBVIRT_BEGIN_ALLOW_THREADS;
695
696
c_retval = virNodeDeviceFree(dev);
697
LIBVIRT_END_ALLOW_THREADS;
698
py_retval = libvirt_intWrap((int) c_retval);
699
return(py_retval);
700
}
701
702
PyObject *
703
libvirt_virSecretGetUsageType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
704
PyObject *py_retval;
705
int c_retval;
706
virSecretPtr secret;
707
PyObject *pyobj_secret;
708
709
if (!PyArg_ParseTuple(args, (char *)"O:virSecretGetUsageType", &pyobj_secret))
710
return(NULL);
711
secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
712
LIBVIRT_BEGIN_ALLOW_THREADS;
713
714
c_retval = virSecretGetUsageType(secret);
715
LIBVIRT_END_ALLOW_THREADS;
716
py_retval = libvirt_intWrap((int) c_retval);
717
return(py_retval);
718
}
719
720
PyObject *
721
libvirt_virNodeDeviceCreateXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
722
PyObject *py_retval;
723
virNodeDevicePtr c_retval;
724
virConnectPtr conn;
725
PyObject *pyobj_conn;
726
char * xmlDesc;
727
unsigned int flags;
728
729
if (!PyArg_ParseTuple(args, (char *)"Ozi:virNodeDeviceCreateXML", &pyobj_conn, &xmlDesc, &flags))
730
return(NULL);
731
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
732
LIBVIRT_BEGIN_ALLOW_THREADS;
733
734
c_retval = virNodeDeviceCreateXML(conn, xmlDesc, flags);
735
LIBVIRT_END_ALLOW_THREADS;
736
py_retval = libvirt_virNodeDevicePtrWrap((virNodeDevicePtr) c_retval);
737
return(py_retval);
738
}
739
740
PyObject *
741
libvirt_virNetworkDestroy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
742
PyObject *py_retval;
743
int c_retval;
744
virNetworkPtr network;
745
PyObject *pyobj_network;
746
747
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkDestroy", &pyobj_network))
748
return(NULL);
749
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
750
LIBVIRT_BEGIN_ALLOW_THREADS;
751
752
c_retval = virNetworkDestroy(network);
753
LIBVIRT_END_ALLOW_THREADS;
754
py_retval = libvirt_intWrap((int) c_retval);
755
return(py_retval);
756
}
757
758
PyObject *
759
libvirt_virStoragePoolLookupByName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
760
PyObject *py_retval;
761
virStoragePoolPtr c_retval;
762
virConnectPtr conn;
763
PyObject *pyobj_conn;
764
char * name;
765
766
if (!PyArg_ParseTuple(args, (char *)"Oz:virStoragePoolLookupByName", &pyobj_conn, &name))
767
return(NULL);
768
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
769
LIBVIRT_BEGIN_ALLOW_THREADS;
770
771
c_retval = virStoragePoolLookupByName(conn, name);
772
LIBVIRT_END_ALLOW_THREADS;
773
py_retval = libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
774
return(py_retval);
775
}
776
777
PyObject *
778
libvirt_virStoragePoolCreateXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
779
PyObject *py_retval;
780
virStoragePoolPtr c_retval;
781
virConnectPtr conn;
782
PyObject *pyobj_conn;
783
char * xmlDesc;
784
unsigned int flags;
785
786
if (!PyArg_ParseTuple(args, (char *)"Ozi:virStoragePoolCreateXML", &pyobj_conn, &xmlDesc, &flags))
787
return(NULL);
788
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
789
LIBVIRT_BEGIN_ALLOW_THREADS;
790
791
c_retval = virStoragePoolCreateXML(conn, xmlDesc, flags);
792
LIBVIRT_END_ALLOW_THREADS;
793
py_retval = libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
794
return(py_retval);
795
}
796
797
PyObject *
798
libvirt_virNetworkGetBridgeName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
799
PyObject *py_retval;
800
char * c_retval;
801
virNetworkPtr network;
802
PyObject *pyobj_network;
803
804
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetBridgeName", &pyobj_network))
805
return(NULL);
806
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
807
LIBVIRT_BEGIN_ALLOW_THREADS;
808
809
c_retval = virNetworkGetBridgeName(network);
810
LIBVIRT_END_ALLOW_THREADS;
811
py_retval = libvirt_charPtrWrap((char *) c_retval);
812
return(py_retval);
813
}
814
815
PyObject *
816
libvirt_virStorageVolGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
817
PyObject *py_retval;
818
char * c_retval;
819
virStorageVolPtr vol;
820
PyObject *pyobj_vol;
821
unsigned int flags;
822
823
if (!PyArg_ParseTuple(args, (char *)"Oi:virStorageVolGetXMLDesc", &pyobj_vol, &flags))
824
return(NULL);
825
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
826
LIBVIRT_BEGIN_ALLOW_THREADS;
827
828
c_retval = virStorageVolGetXMLDesc(vol, flags);
829
LIBVIRT_END_ALLOW_THREADS;
830
py_retval = libvirt_charPtrWrap((char *) c_retval);
831
return(py_retval);
832
}
833
834
PyObject *
835
libvirt_virConnectDomainXMLToNative(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
836
PyObject *py_retval;
837
char * c_retval;
838
virConnectPtr conn;
839
PyObject *pyobj_conn;
840
char * nativeFormat;
841
char * domainXml;
842
unsigned int flags;
843
844
if (!PyArg_ParseTuple(args, (char *)"Ozzi:virConnectDomainXMLToNative", &pyobj_conn, &nativeFormat, &domainXml, &flags))
845
return(NULL);
846
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
847
LIBVIRT_BEGIN_ALLOW_THREADS;
848
849
c_retval = virConnectDomainXMLToNative(conn, nativeFormat, domainXml, flags);
850
LIBVIRT_END_ALLOW_THREADS;
851
py_retval = libvirt_charPtrWrap((char *) c_retval);
852
return(py_retval);
853
}
854
855
PyObject *
856
libvirt_virConnectGetType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
857
PyObject *py_retval;
858
const char * c_retval;
859
virConnectPtr conn;
860
PyObject *pyobj_conn;
861
862
if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetType", &pyobj_conn))
863
return(NULL);
864
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
865
LIBVIRT_BEGIN_ALLOW_THREADS;
866
867
c_retval = virConnectGetType(conn);
868
LIBVIRT_END_ALLOW_THREADS;
869
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
870
return(py_retval);
871
}
872
873
PyObject *
874
libvirt_virStorageVolCreateXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
875
PyObject *py_retval;
876
virStorageVolPtr c_retval;
877
virStoragePoolPtr pool;
878
PyObject *pyobj_pool;
879
char * xmldesc;
880
unsigned int flags;
881
882
if (!PyArg_ParseTuple(args, (char *)"Ozi:virStorageVolCreateXML", &pyobj_pool, &xmldesc, &flags))
883
return(NULL);
884
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
885
LIBVIRT_BEGIN_ALLOW_THREADS;
886
887
c_retval = virStorageVolCreateXML(pool, xmldesc, flags);
888
LIBVIRT_END_ALLOW_THREADS;
889
py_retval = libvirt_virStorageVolPtrWrap((virStorageVolPtr) c_retval);
890
return(py_retval);
891
}
892
893
PyObject *
894
libvirt_virDomainSave(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
895
PyObject *py_retval;
896
int c_retval;
897
virDomainPtr domain;
898
PyObject *pyobj_domain;
899
char * to;
900
901
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainSave", &pyobj_domain, &to))
902
return(NULL);
903
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
904
LIBVIRT_BEGIN_ALLOW_THREADS;
905
906
c_retval = virDomainSave(domain, to);
907
LIBVIRT_END_ALLOW_THREADS;
908
py_retval = libvirt_intWrap((int) c_retval);
909
return(py_retval);
910
}
911
912
PyObject *
913
libvirt_virDomainCreate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
914
PyObject *py_retval;
915
int c_retval;
916
virDomainPtr domain;
917
PyObject *pyobj_domain;
918
919
if (!PyArg_ParseTuple(args, (char *)"O:virDomainCreate", &pyobj_domain))
920
return(NULL);
921
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
922
LIBVIRT_BEGIN_ALLOW_THREADS;
923
924
c_retval = virDomainCreate(domain);
925
LIBVIRT_END_ALLOW_THREADS;
926
py_retval = libvirt_intWrap((int) c_retval);
927
return(py_retval);
928
}
929
930
PyObject *
931
libvirt_virDomainCoreDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
932
PyObject *py_retval;
933
int c_retval;
934
virDomainPtr domain;
935
PyObject *pyobj_domain;
936
char * to;
937
int flags;
938
939
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainCoreDump", &pyobj_domain, &to, &flags))
940
return(NULL);
941
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
942
LIBVIRT_BEGIN_ALLOW_THREADS;
943
944
c_retval = virDomainCoreDump(domain, to, flags);
945
LIBVIRT_END_ALLOW_THREADS;
946
py_retval = libvirt_intWrap((int) c_retval);
947
return(py_retval);
948
}
949
950
PyObject *
951
libvirt_virDomainSetMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
952
PyObject *py_retval;
953
int c_retval;
954
virDomainPtr domain;
955
PyObject *pyobj_domain;
956
unsigned long memory;
957
958
if (!PyArg_ParseTuple(args, (char *)"Ol:virDomainSetMemory", &pyobj_domain, &memory))
959
return(NULL);
960
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
961
LIBVIRT_BEGIN_ALLOW_THREADS;
962
963
c_retval = virDomainSetMemory(domain, memory);
964
LIBVIRT_END_ALLOW_THREADS;
965
py_retval = libvirt_intWrap((int) c_retval);
966
return(py_retval);
967
}
968
969
PyObject *
970
libvirt_virConnectIsSecure(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
971
PyObject *py_retval;
972
int c_retval;
973
virConnectPtr conn;
974
PyObject *pyobj_conn;
975
976
if (!PyArg_ParseTuple(args, (char *)"O:virConnectIsSecure", &pyobj_conn))
977
return(NULL);
978
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
979
LIBVIRT_BEGIN_ALLOW_THREADS;
980
981
c_retval = virConnectIsSecure(conn);
982
LIBVIRT_END_ALLOW_THREADS;
983
py_retval = libvirt_intWrap((int) c_retval);
984
return(py_retval);
985
}
986
987
PyObject *
988
libvirt_virResetLastError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
989
LIBVIRT_BEGIN_ALLOW_THREADS;
990
991
virResetLastError();
992
LIBVIRT_END_ALLOW_THREADS;
993
Py_INCREF(Py_None);
994
return(Py_None);
995
}
996
997
PyObject *
998
libvirt_virInterfaceGetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
999
PyObject *py_retval;
1000
const char * c_retval;
1001
virInterfacePtr iface;
1002
PyObject *pyobj_iface;
1003
1004
if (!PyArg_ParseTuple(args, (char *)"O:virInterfaceGetName", &pyobj_iface))
1005
return(NULL);
1006
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
1007
LIBVIRT_BEGIN_ALLOW_THREADS;
1008
1009
c_retval = virInterfaceGetName(iface);
1010
LIBVIRT_END_ALLOW_THREADS;
1011
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
1012
return(py_retval);
1013
}
1014
1015
PyObject *
1016
libvirt_virStoragePoolCreate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1017
PyObject *py_retval;
1018
int c_retval;
1019
virStoragePoolPtr pool;
1020
PyObject *pyobj_pool;
1021
unsigned int flags;
1022
1023
if (!PyArg_ParseTuple(args, (char *)"Oi:virStoragePoolCreate", &pyobj_pool, &flags))
1024
return(NULL);
1025
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1026
LIBVIRT_BEGIN_ALLOW_THREADS;
1027
1028
c_retval = virStoragePoolCreate(pool, flags);
1029
LIBVIRT_END_ALLOW_THREADS;
1030
py_retval = libvirt_intWrap((int) c_retval);
1031
return(py_retval);
1032
}
1033
1034
PyObject *
1035
libvirt_virStoragePoolDelete(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1036
PyObject *py_retval;
1037
int c_retval;
1038
virStoragePoolPtr pool;
1039
PyObject *pyobj_pool;
1040
unsigned int flags;
1041
1042
if (!PyArg_ParseTuple(args, (char *)"Oi:virStoragePoolDelete", &pyobj_pool, &flags))
1043
return(NULL);
1044
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1045
LIBVIRT_BEGIN_ALLOW_THREADS;
1046
1047
c_retval = virStoragePoolDelete(pool, flags);
1048
LIBVIRT_END_ALLOW_THREADS;
1049
py_retval = libvirt_intWrap((int) c_retval);
1050
return(py_retval);
1051
}
1052
1053
PyObject *
1054
libvirt_virNetworkSetAutostart(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1055
PyObject *py_retval;
1056
int c_retval;
1057
virNetworkPtr network;
1058
PyObject *pyobj_network;
1059
int autostart;
1060
1061
if (!PyArg_ParseTuple(args, (char *)"Oi:virNetworkSetAutostart", &pyobj_network, &autostart))
1062
return(NULL);
1063
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
1064
LIBVIRT_BEGIN_ALLOW_THREADS;
1065
1066
c_retval = virNetworkSetAutostart(network, autostart);
1067
LIBVIRT_END_ALLOW_THREADS;
1068
py_retval = libvirt_intWrap((int) c_retval);
1069
return(py_retval);
1070
}
1071
1072
PyObject *
1073
libvirt_virSecretLookupByUUIDString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1074
PyObject *py_retval;
1075
virSecretPtr c_retval;
1076
virConnectPtr conn;
1077
PyObject *pyobj_conn;
1078
char * uuidstr;
1079
1080
if (!PyArg_ParseTuple(args, (char *)"Oz:virSecretLookupByUUIDString", &pyobj_conn, &uuidstr))
1081
return(NULL);
1082
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1083
LIBVIRT_BEGIN_ALLOW_THREADS;
1084
1085
c_retval = virSecretLookupByUUIDString(conn, uuidstr);
1086
LIBVIRT_END_ALLOW_THREADS;
1087
py_retval = libvirt_virSecretPtrWrap((virSecretPtr) c_retval);
1088
return(py_retval);
1089
}
1090
1091
PyObject *
1092
libvirt_virDomainGetMaxMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1093
PyObject *py_retval;
1094
unsigned long c_retval;
1095
virDomainPtr domain;
1096
PyObject *pyobj_domain;
1097
1098
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetMaxMemory", &pyobj_domain))
1099
return(NULL);
1100
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1101
LIBVIRT_BEGIN_ALLOW_THREADS;
1102
1103
c_retval = virDomainGetMaxMemory(domain);
1104
LIBVIRT_END_ALLOW_THREADS;
1105
py_retval = libvirt_longWrap((long) c_retval);
1106
return(py_retval);
1107
}
1108
1109
PyObject *
1110
libvirt_virStreamAbort(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1111
PyObject *py_retval;
1112
int c_retval;
1113
virStreamPtr stream;
1114
PyObject *pyobj_stream;
1115
1116
if (!PyArg_ParseTuple(args, (char *)"O:virStreamAbort", &pyobj_stream))
1117
return(NULL);
1118
stream = (virStreamPtr) PyvirStream_Get(pyobj_stream);
1119
LIBVIRT_BEGIN_ALLOW_THREADS;
1120
1121
c_retval = virStreamAbort(stream);
1122
LIBVIRT_END_ALLOW_THREADS;
1123
py_retval = libvirt_intWrap((int) c_retval);
1124
return(py_retval);
1125
}
1126
1127
PyObject *
1128
libvirt_virDomainSetMaxMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1129
PyObject *py_retval;
1130
int c_retval;
1131
virDomainPtr domain;
1132
PyObject *pyobj_domain;
1133
unsigned long memory;
1134
1135
if (!PyArg_ParseTuple(args, (char *)"Ol:virDomainSetMaxMemory", &pyobj_domain, &memory))
1136
return(NULL);
1137
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1138
LIBVIRT_BEGIN_ALLOW_THREADS;
1139
1140
c_retval = virDomainSetMaxMemory(domain, memory);
1141
LIBVIRT_END_ALLOW_THREADS;
1142
py_retval = libvirt_intWrap((int) c_retval);
1143
return(py_retval);
1144
}
1145
1146
PyObject *
1147
libvirt_virNetworkIsPersistent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1148
PyObject *py_retval;
1149
int c_retval;
1150
virNetworkPtr net;
1151
PyObject *pyobj_net;
1152
1153
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkIsPersistent", &pyobj_net))
1154
return(NULL);
1155
net = (virNetworkPtr) PyvirNetwork_Get(pyobj_net);
1156
LIBVIRT_BEGIN_ALLOW_THREADS;
1157
1158
c_retval = virNetworkIsPersistent(net);
1159
LIBVIRT_END_ALLOW_THREADS;
1160
py_retval = libvirt_intWrap((int) c_retval);
1161
return(py_retval);
1162
}
1163
1164
PyObject *
1165
libvirt_virNodeDeviceDestroy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1166
PyObject *py_retval;
1167
int c_retval;
1168
virNodeDevicePtr dev;
1169
PyObject *pyobj_dev;
1170
1171
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceDestroy", &pyobj_dev))
1172
return(NULL);
1173
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
1174
LIBVIRT_BEGIN_ALLOW_THREADS;
1175
1176
c_retval = virNodeDeviceDestroy(dev);
1177
LIBVIRT_END_ALLOW_THREADS;
1178
py_retval = libvirt_intWrap((int) c_retval);
1179
return(py_retval);
1180
}
1181
1182
PyObject *
1183
libvirt_virStoragePoolFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1184
PyObject *py_retval;
1185
int c_retval;
1186
virStoragePoolPtr pool;
1187
PyObject *pyobj_pool;
1188
1189
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolFree", &pyobj_pool))
1190
return(NULL);
1191
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1192
LIBVIRT_BEGIN_ALLOW_THREADS;
1193
1194
c_retval = virStoragePoolFree(pool);
1195
LIBVIRT_END_ALLOW_THREADS;
1196
py_retval = libvirt_intWrap((int) c_retval);
1197
return(py_retval);
1198
}
1199
1200
PyObject *
1201
libvirt_virConnectNumOfDefinedInterfaces(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1202
PyObject *py_retval;
1203
int c_retval;
1204
virConnectPtr conn;
1205
PyObject *pyobj_conn;
1206
1207
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfDefinedInterfaces", &pyobj_conn))
1208
return(NULL);
1209
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1210
LIBVIRT_BEGIN_ALLOW_THREADS;
1211
1212
c_retval = virConnectNumOfDefinedInterfaces(conn);
1213
LIBVIRT_END_ALLOW_THREADS;
1214
py_retval = libvirt_intWrap((int) c_retval);
1215
return(py_retval);
1216
}
1217
1218
PyObject *
1219
libvirt_virNetworkDefineXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1220
PyObject *py_retval;
1221
virNetworkPtr c_retval;
1222
virConnectPtr conn;
1223
PyObject *pyobj_conn;
1224
char * xml;
1225
1226
if (!PyArg_ParseTuple(args, (char *)"Oz:virNetworkDefineXML", &pyobj_conn, &xml))
1227
return(NULL);
1228
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1229
LIBVIRT_BEGIN_ALLOW_THREADS;
1230
1231
c_retval = virNetworkDefineXML(conn, xml);
1232
LIBVIRT_END_ALLOW_THREADS;
1233
py_retval = libvirt_virNetworkPtrWrap((virNetworkPtr) c_retval);
1234
return(py_retval);
1235
}
1236
1237
PyObject *
1238
libvirt_virConnResetLastError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1239
virConnectPtr conn;
1240
PyObject *pyobj_conn;
1241
1242
if (!PyArg_ParseTuple(args, (char *)"O:virConnResetLastError", &pyobj_conn))
1243
return(NULL);
1244
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1245
LIBVIRT_BEGIN_ALLOW_THREADS;
1246
1247
virConnResetLastError(conn);
1248
LIBVIRT_END_ALLOW_THREADS;
1249
Py_INCREF(Py_None);
1250
return(Py_None);
1251
}
1252
1253
PyObject *
1254
libvirt_virDomainResume(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1255
PyObject *py_retval;
1256
int c_retval;
1257
virDomainPtr domain;
1258
PyObject *pyobj_domain;
1259
1260
if (!PyArg_ParseTuple(args, (char *)"O:virDomainResume", &pyobj_domain))
1261
return(NULL);
1262
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1263
LIBVIRT_BEGIN_ALLOW_THREADS;
1264
1265
c_retval = virDomainResume(domain);
1266
LIBVIRT_END_ALLOW_THREADS;
1267
py_retval = libvirt_intWrap((int) c_retval);
1268
return(py_retval);
1269
}
1270
1271
PyObject *
1272
libvirt_virStreamNew(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1273
PyObject *py_retval;
1274
virStreamPtr c_retval;
1275
virConnectPtr conn;
1276
PyObject *pyobj_conn;
1277
unsigned int flags;
1278
1279
if (!PyArg_ParseTuple(args, (char *)"Oi:virStreamNew", &pyobj_conn, &flags))
1280
return(NULL);
1281
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1282
LIBVIRT_BEGIN_ALLOW_THREADS;
1283
1284
c_retval = virStreamNew(conn, flags);
1285
LIBVIRT_END_ALLOW_THREADS;
1286
py_retval = libvirt_virStreamPtrWrap((virStreamPtr) c_retval);
1287
return(py_retval);
1288
}
1289
1290
PyObject *
1291
libvirt_virConnectGetHostname(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1292
PyObject *py_retval;
1293
char * c_retval;
1294
virConnectPtr conn;
1295
PyObject *pyobj_conn;
1296
1297
if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetHostname", &pyobj_conn))
1298
return(NULL);
1299
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1300
LIBVIRT_BEGIN_ALLOW_THREADS;
1301
1302
c_retval = virConnectGetHostname(conn);
1303
LIBVIRT_END_ALLOW_THREADS;
1304
py_retval = libvirt_charPtrWrap((char *) c_retval);
1305
return(py_retval);
1306
}
1307
1308
PyObject *
1309
libvirt_virDomainIsActive(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1310
PyObject *py_retval;
1311
int c_retval;
1312
virDomainPtr dom;
1313
PyObject *pyobj_dom;
1314
1315
if (!PyArg_ParseTuple(args, (char *)"O:virDomainIsActive", &pyobj_dom))
1316
return(NULL);
1317
dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
1318
LIBVIRT_BEGIN_ALLOW_THREADS;
1319
1320
c_retval = virDomainIsActive(dom);
1321
LIBVIRT_END_ALLOW_THREADS;
1322
py_retval = libvirt_intWrap((int) c_retval);
1323
return(py_retval);
1324
}
1325
1326
PyObject *
1327
libvirt_virNodeDeviceGetParent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1328
PyObject *py_retval;
1329
const char * c_retval;
1330
virNodeDevicePtr dev;
1331
PyObject *pyobj_dev;
1332
1333
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceGetParent", &pyobj_dev))
1334
return(NULL);
1335
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
1336
LIBVIRT_BEGIN_ALLOW_THREADS;
1337
1338
c_retval = virNodeDeviceGetParent(dev);
1339
LIBVIRT_END_ALLOW_THREADS;
1340
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
1341
return(py_retval);
1342
}
1343
1344
PyObject *
1345
libvirt_virDomainDetachDeviceFlags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1346
PyObject *py_retval;
1347
int c_retval;
1348
virDomainPtr domain;
1349
PyObject *pyobj_domain;
1350
char * xml;
1351
unsigned int flags;
1352
1353
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainDetachDeviceFlags", &pyobj_domain, &xml, &flags))
1354
return(NULL);
1355
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1356
LIBVIRT_BEGIN_ALLOW_THREADS;
1357
1358
c_retval = virDomainDetachDeviceFlags(domain, xml, flags);
1359
LIBVIRT_END_ALLOW_THREADS;
1360
py_retval = libvirt_intWrap((int) c_retval);
1361
return(py_retval);
1362
}
1363
1364
PyObject *
1365
libvirt_virDomainGetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1366
PyObject *py_retval;
1367
const char * c_retval;
1368
virDomainPtr domain;
1369
PyObject *pyobj_domain;
1370
1371
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetName", &pyobj_domain))
1372
return(NULL);
1373
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1374
LIBVIRT_BEGIN_ALLOW_THREADS;
1375
1376
c_retval = virDomainGetName(domain);
1377
LIBVIRT_END_ALLOW_THREADS;
1378
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
1379
return(py_retval);
1380
}
1381
1382
PyObject *
1383
libvirt_virNetworkGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1384
PyObject *py_retval;
1385
char * c_retval;
1386
virNetworkPtr network;
1387
PyObject *pyobj_network;
1388
int flags;
1389
1390
if (!PyArg_ParseTuple(args, (char *)"Oi:virNetworkGetXMLDesc", &pyobj_network, &flags))
1391
return(NULL);
1392
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
1393
LIBVIRT_BEGIN_ALLOW_THREADS;
1394
1395
c_retval = virNetworkGetXMLDesc(network, flags);
1396
LIBVIRT_END_ALLOW_THREADS;
1397
py_retval = libvirt_charPtrWrap((char *) c_retval);
1398
return(py_retval);
1399
}
1400
1401
PyObject *
1402
libvirt_virConnectNumOfStoragePools(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1403
PyObject *py_retval;
1404
int c_retval;
1405
virConnectPtr conn;
1406
PyObject *pyobj_conn;
1407
1408
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfStoragePools", &pyobj_conn))
1409
return(NULL);
1410
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1411
LIBVIRT_BEGIN_ALLOW_THREADS;
1412
1413
c_retval = virConnectNumOfStoragePools(conn);
1414
LIBVIRT_END_ALLOW_THREADS;
1415
py_retval = libvirt_intWrap((int) c_retval);
1416
return(py_retval);
1417
}
1418
1419
PyObject *
1420
libvirt_virStoragePoolIsPersistent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1421
PyObject *py_retval;
1422
int c_retval;
1423
virStoragePoolPtr pool;
1424
PyObject *pyobj_pool;
1425
1426
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolIsPersistent", &pyobj_pool))
1427
return(NULL);
1428
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1429
LIBVIRT_BEGIN_ALLOW_THREADS;
1430
1431
c_retval = virStoragePoolIsPersistent(pool);
1432
LIBVIRT_END_ALLOW_THREADS;
1433
py_retval = libvirt_intWrap((int) c_retval);
1434
return(py_retval);
1435
}
1436
1437
PyObject *
1438
libvirt_virStoragePoolNumOfVolumes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1439
PyObject *py_retval;
1440
int c_retval;
1441
virStoragePoolPtr pool;
1442
PyObject *pyobj_pool;
1443
1444
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolNumOfVolumes", &pyobj_pool))
1445
return(NULL);
1446
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1447
LIBVIRT_BEGIN_ALLOW_THREADS;
1448
1449
c_retval = virStoragePoolNumOfVolumes(pool);
1450
LIBVIRT_END_ALLOW_THREADS;
1451
py_retval = libvirt_intWrap((int) c_retval);
1452
return(py_retval);
1453
}
1454
1455
PyObject *
1456
libvirt_virNetworkGetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1457
PyObject *py_retval;
1458
const char * c_retval;
1459
virNetworkPtr network;
1460
PyObject *pyobj_network;
1461
1462
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetName", &pyobj_network))
1463
return(NULL);
1464
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
1465
LIBVIRT_BEGIN_ALLOW_THREADS;
1466
1467
c_retval = virNetworkGetName(network);
1468
LIBVIRT_END_ALLOW_THREADS;
1469
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
1470
return(py_retval);
1471
}
1472
1473
PyObject *
1474
libvirt_virSecretGetXMLDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1475
PyObject *py_retval;
1476
char * c_retval;
1477
virSecretPtr secret;
1478
PyObject *pyobj_secret;
1479
unsigned int flags;
1480
1481
if (!PyArg_ParseTuple(args, (char *)"Oi:virSecretGetXMLDesc", &pyobj_secret, &flags))
1482
return(NULL);
1483
secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
1484
LIBVIRT_BEGIN_ALLOW_THREADS;
1485
1486
c_retval = virSecretGetXMLDesc(secret, flags);
1487
LIBVIRT_END_ALLOW_THREADS;
1488
py_retval = libvirt_charPtrWrap((char *) c_retval);
1489
return(py_retval);
1490
}
1491
1492
PyObject *
1493
libvirt_virConnectGetCapabilities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1494
PyObject *py_retval;
1495
char * c_retval;
1496
virConnectPtr conn;
1497
PyObject *pyobj_conn;
1498
1499
if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetCapabilities", &pyobj_conn))
1500
return(NULL);
1501
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1502
LIBVIRT_BEGIN_ALLOW_THREADS;
1503
1504
c_retval = virConnectGetCapabilities(conn);
1505
LIBVIRT_END_ALLOW_THREADS;
1506
py_retval = libvirt_charPtrWrap((char *) c_retval);
1507
return(py_retval);
1508
}
1509
1510
PyObject *
1511
libvirt_virDomainLookupByName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1512
PyObject *py_retval;
1513
virDomainPtr c_retval;
1514
virConnectPtr conn;
1515
PyObject *pyobj_conn;
1516
char * name;
1517
1518
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainLookupByName", &pyobj_conn, &name))
1519
return(NULL);
1520
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1521
LIBVIRT_BEGIN_ALLOW_THREADS;
1522
1523
c_retval = virDomainLookupByName(conn, name);
1524
LIBVIRT_END_ALLOW_THREADS;
1525
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
1526
return(py_retval);
1527
}
1528
1529
PyObject *
1530
libvirt_virConnectFindStoragePoolSources(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1531
PyObject *py_retval;
1532
char * c_retval;
1533
virConnectPtr conn;
1534
PyObject *pyobj_conn;
1535
char * type;
1536
char * srcSpec;
1537
unsigned int flags;
1538
1539
if (!PyArg_ParseTuple(args, (char *)"Ozzi:virConnectFindStoragePoolSources", &pyobj_conn, &type, &srcSpec, &flags))
1540
return(NULL);
1541
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1542
LIBVIRT_BEGIN_ALLOW_THREADS;
1543
1544
c_retval = virConnectFindStoragePoolSources(conn, type, srcSpec, flags);
1545
LIBVIRT_END_ALLOW_THREADS;
1546
py_retval = libvirt_charPtrWrap((char *) c_retval);
1547
return(py_retval);
1548
}
1549
1550
PyObject *
1551
libvirt_virStorageVolFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1552
PyObject *py_retval;
1553
int c_retval;
1554
virStorageVolPtr vol;
1555
PyObject *pyobj_vol;
1556
1557
if (!PyArg_ParseTuple(args, (char *)"O:virStorageVolFree", &pyobj_vol))
1558
return(NULL);
1559
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
1560
LIBVIRT_BEGIN_ALLOW_THREADS;
1561
1562
c_retval = virStorageVolFree(vol);
1563
LIBVIRT_END_ALLOW_THREADS;
1564
py_retval = libvirt_intWrap((int) c_retval);
1565
return(py_retval);
1566
}
1567
1568
PyObject *
1569
libvirt_virDomainRestore(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1570
PyObject *py_retval;
1571
int c_retval;
1572
virConnectPtr conn;
1573
PyObject *pyobj_conn;
1574
char * frm;
1575
1576
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainRestore", &pyobj_conn, &frm))
1577
return(NULL);
1578
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1579
LIBVIRT_BEGIN_ALLOW_THREADS;
1580
1581
c_retval = virDomainRestore(conn, frm);
1582
LIBVIRT_END_ALLOW_THREADS;
1583
py_retval = libvirt_intWrap((int) c_retval);
1584
return(py_retval);
1585
}
1586
1587
PyObject *
1588
libvirt_virStorageVolGetPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1589
PyObject *py_retval;
1590
char * c_retval;
1591
virStorageVolPtr vol;
1592
PyObject *pyobj_vol;
1593
1594
if (!PyArg_ParseTuple(args, (char *)"O:virStorageVolGetPath", &pyobj_vol))
1595
return(NULL);
1596
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
1597
LIBVIRT_BEGIN_ALLOW_THREADS;
1598
1599
c_retval = virStorageVolGetPath(vol);
1600
LIBVIRT_END_ALLOW_THREADS;
1601
py_retval = libvirt_charPtrWrap((char *) c_retval);
1602
return(py_retval);
1603
}
1604
1605
PyObject *
1606
libvirt_virNetworkLookupByUUIDString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1607
PyObject *py_retval;
1608
virNetworkPtr c_retval;
1609
virConnectPtr conn;
1610
PyObject *pyobj_conn;
1611
char * uuidstr;
1612
1613
if (!PyArg_ParseTuple(args, (char *)"Oz:virNetworkLookupByUUIDString", &pyobj_conn, &uuidstr))
1614
return(NULL);
1615
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1616
LIBVIRT_BEGIN_ALLOW_THREADS;
1617
1618
c_retval = virNetworkLookupByUUIDString(conn, uuidstr);
1619
LIBVIRT_END_ALLOW_THREADS;
1620
py_retval = libvirt_virNetworkPtrWrap((virNetworkPtr) c_retval);
1621
return(py_retval);
1622
}
1623
1624
PyObject *
1625
libvirt_virDomainLookupByID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1626
PyObject *py_retval;
1627
virDomainPtr c_retval;
1628
virConnectPtr conn;
1629
PyObject *pyobj_conn;
1630
int id;
1631
1632
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainLookupByID", &pyobj_conn, &id))
1633
return(NULL);
1634
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1635
LIBVIRT_BEGIN_ALLOW_THREADS;
1636
1637
c_retval = virDomainLookupByID(conn, id);
1638
LIBVIRT_END_ALLOW_THREADS;
1639
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
1640
return(py_retval);
1641
}
1642
1643
PyObject *
1644
libvirt_virSecretUndefine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1645
PyObject *py_retval;
1646
int c_retval;
1647
virSecretPtr secret;
1648
PyObject *pyobj_secret;
1649
1650
if (!PyArg_ParseTuple(args, (char *)"O:virSecretUndefine", &pyobj_secret))
1651
return(NULL);
1652
secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
1653
LIBVIRT_BEGIN_ALLOW_THREADS;
1654
1655
c_retval = virSecretUndefine(secret);
1656
LIBVIRT_END_ALLOW_THREADS;
1657
py_retval = libvirt_intWrap((int) c_retval);
1658
return(py_retval);
1659
}
1660
1661
PyObject *
1662
libvirt_virNetworkCreateXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1663
PyObject *py_retval;
1664
virNetworkPtr c_retval;
1665
virConnectPtr conn;
1666
PyObject *pyobj_conn;
1667
char * xmlDesc;
1668
1669
if (!PyArg_ParseTuple(args, (char *)"Oz:virNetworkCreateXML", &pyobj_conn, &xmlDesc))
1670
return(NULL);
1671
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1672
LIBVIRT_BEGIN_ALLOW_THREADS;
1673
1674
c_retval = virNetworkCreateXML(conn, xmlDesc);
1675
LIBVIRT_END_ALLOW_THREADS;
1676
py_retval = libvirt_virNetworkPtrWrap((virNetworkPtr) c_retval);
1677
return(py_retval);
1678
}
1679
1680
PyObject *
1681
libvirt_virNetworkUndefine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1682
PyObject *py_retval;
1683
int c_retval;
1684
virNetworkPtr network;
1685
PyObject *pyobj_network;
1686
1687
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkUndefine", &pyobj_network))
1688
return(NULL);
1689
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
1690
LIBVIRT_BEGIN_ALLOW_THREADS;
1691
1692
c_retval = virNetworkUndefine(network);
1693
LIBVIRT_END_ALLOW_THREADS;
1694
py_retval = libvirt_intWrap((int) c_retval);
1695
return(py_retval);
1696
}
1697
1698
PyObject *
1699
libvirt_virDomainMigrateToURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1700
PyObject *py_retval;
1701
int c_retval;
1702
virDomainPtr domain;
1703
PyObject *pyobj_domain;
1704
char * duri;
1705
unsigned long flags;
1706
char * dname;
1707
unsigned long bandwidth;
1708
1709
if (!PyArg_ParseTuple(args, (char *)"Ozlzl:virDomainMigrateToURI", &pyobj_domain, &duri, &flags, &dname, &bandwidth))
1710
return(NULL);
1711
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1712
LIBVIRT_BEGIN_ALLOW_THREADS;
1713
1714
c_retval = virDomainMigrateToURI(domain, duri, flags, dname, bandwidth);
1715
LIBVIRT_END_ALLOW_THREADS;
1716
py_retval = libvirt_intWrap((int) c_retval);
1717
return(py_retval);
1718
}
1719
1720
PyObject *
1721
libvirt_virNodeDeviceLookupByName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1722
PyObject *py_retval;
1723
virNodeDevicePtr c_retval;
1724
virConnectPtr conn;
1725
PyObject *pyobj_conn;
1726
char * name;
1727
1728
if (!PyArg_ParseTuple(args, (char *)"Oz:virNodeDeviceLookupByName", &pyobj_conn, &name))
1729
return(NULL);
1730
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1731
LIBVIRT_BEGIN_ALLOW_THREADS;
1732
1733
c_retval = virNodeDeviceLookupByName(conn, name);
1734
LIBVIRT_END_ALLOW_THREADS;
1735
py_retval = libvirt_virNodeDevicePtrWrap((virNodeDevicePtr) c_retval);
1736
return(py_retval);
1737
}
1738
1739
PyObject *
1740
libvirt_virInterfaceGetMACString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1741
PyObject *py_retval;
1742
const char * c_retval;
1743
virInterfacePtr iface;
1744
PyObject *pyobj_iface;
1745
1746
if (!PyArg_ParseTuple(args, (char *)"O:virInterfaceGetMACString", &pyobj_iface))
1747
return(NULL);
1748
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
1749
LIBVIRT_BEGIN_ALLOW_THREADS;
1750
1751
c_retval = virInterfaceGetMACString(iface);
1752
LIBVIRT_END_ALLOW_THREADS;
1753
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
1754
return(py_retval);
1755
}
1756
1757
PyObject *
1758
libvirt_virConnectNumOfDomains(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1759
PyObject *py_retval;
1760
int c_retval;
1761
virConnectPtr conn;
1762
PyObject *pyobj_conn;
1763
1764
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfDomains", &pyobj_conn))
1765
return(NULL);
1766
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1767
LIBVIRT_BEGIN_ALLOW_THREADS;
1768
1769
c_retval = virConnectNumOfDomains(conn);
1770
LIBVIRT_END_ALLOW_THREADS;
1771
py_retval = libvirt_intWrap((int) c_retval);
1772
return(py_retval);
1773
}
1774
1775
PyObject *
1776
libvirt_virStoragePoolRefresh(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1777
PyObject *py_retval;
1778
int c_retval;
1779
virStoragePoolPtr pool;
1780
PyObject *pyobj_pool;
1781
unsigned int flags;
1782
1783
if (!PyArg_ParseTuple(args, (char *)"Oi:virStoragePoolRefresh", &pyobj_pool, &flags))
1784
return(NULL);
1785
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1786
LIBVIRT_BEGIN_ALLOW_THREADS;
1787
1788
c_retval = virStoragePoolRefresh(pool, flags);
1789
LIBVIRT_END_ALLOW_THREADS;
1790
py_retval = libvirt_intWrap((int) c_retval);
1791
return(py_retval);
1792
}
1793
1794
PyObject *
1795
libvirt_virConnectNumOfDefinedDomains(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1796
PyObject *py_retval;
1797
int c_retval;
1798
virConnectPtr conn;
1799
PyObject *pyobj_conn;
1800
1801
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfDefinedDomains", &pyobj_conn))
1802
return(NULL);
1803
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1804
LIBVIRT_BEGIN_ALLOW_THREADS;
1805
1806
c_retval = virConnectNumOfDefinedDomains(conn);
1807
LIBVIRT_END_ALLOW_THREADS;
1808
py_retval = libvirt_intWrap((int) c_retval);
1809
return(py_retval);
1810
}
1811
1812
PyObject *
1813
libvirt_virInitialize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1814
PyObject *py_retval;
1815
int c_retval;
1816
LIBVIRT_BEGIN_ALLOW_THREADS;
1817
1818
c_retval = virInitialize();
1819
LIBVIRT_END_ALLOW_THREADS;
1820
py_retval = libvirt_intWrap((int) c_retval);
1821
return(py_retval);
1822
}
1823
1824
PyObject *
1825
libvirt_virDomainAttachDeviceFlags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1826
PyObject *py_retval;
1827
int c_retval;
1828
virDomainPtr domain;
1829
PyObject *pyobj_domain;
1830
char * xml;
1831
unsigned int flags;
1832
1833
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainAttachDeviceFlags", &pyobj_domain, &xml, &flags))
1834
return(NULL);
1835
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1836
LIBVIRT_BEGIN_ALLOW_THREADS;
1837
1838
c_retval = virDomainAttachDeviceFlags(domain, xml, flags);
1839
LIBVIRT_END_ALLOW_THREADS;
1840
py_retval = libvirt_intWrap((int) c_retval);
1841
return(py_retval);
1842
}
1843
1844
PyObject *
1845
libvirt_virStorageVolCreateXMLFrom(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1846
PyObject *py_retval;
1847
virStorageVolPtr c_retval;
1848
virStoragePoolPtr pool;
1849
PyObject *pyobj_pool;
1850
char * xmldesc;
1851
virStorageVolPtr clonevol;
1852
PyObject *pyobj_clonevol;
1853
unsigned int flags;
1854
1855
if (!PyArg_ParseTuple(args, (char *)"OzOi:virStorageVolCreateXMLFrom", &pyobj_pool, &xmldesc, &pyobj_clonevol, &flags))
1856
return(NULL);
1857
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
1858
clonevol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_clonevol);
1859
LIBVIRT_BEGIN_ALLOW_THREADS;
1860
1861
c_retval = virStorageVolCreateXMLFrom(pool, xmldesc, clonevol, flags);
1862
LIBVIRT_END_ALLOW_THREADS;
1863
py_retval = libvirt_virStorageVolPtrWrap((virStorageVolPtr) c_retval);
1864
return(py_retval);
1865
}
1866
1867
PyObject *
1868
libvirt_virConnectClose(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1869
PyObject *py_retval;
1870
int c_retval;
1871
virConnectPtr conn;
1872
PyObject *pyobj_conn;
1873
1874
if (!PyArg_ParseTuple(args, (char *)"O:virConnectClose", &pyobj_conn))
1875
return(NULL);
1876
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1877
LIBVIRT_BEGIN_ALLOW_THREADS;
1878
1879
c_retval = virConnectClose(conn);
1880
LIBVIRT_END_ALLOW_THREADS;
1881
py_retval = libvirt_intWrap((int) c_retval);
1882
return(py_retval);
1883
}
1884
1885
PyObject *
1886
libvirt_virDomainReboot(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1887
PyObject *py_retval;
1888
int c_retval;
1889
virDomainPtr domain;
1890
PyObject *pyobj_domain;
1891
unsigned int flags;
1892
1893
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainReboot", &pyobj_domain, &flags))
1894
return(NULL);
1895
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1896
LIBVIRT_BEGIN_ALLOW_THREADS;
1897
1898
c_retval = virDomainReboot(domain, flags);
1899
LIBVIRT_END_ALLOW_THREADS;
1900
py_retval = libvirt_intWrap((int) c_retval);
1901
return(py_retval);
1902
}
1903
1904
PyObject *
1905
libvirt_virNetworkLookupByName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1906
PyObject *py_retval;
1907
virNetworkPtr c_retval;
1908
virConnectPtr conn;
1909
PyObject *pyobj_conn;
1910
char * name;
1911
1912
if (!PyArg_ParseTuple(args, (char *)"Oz:virNetworkLookupByName", &pyobj_conn, &name))
1913
return(NULL);
1914
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1915
LIBVIRT_BEGIN_ALLOW_THREADS;
1916
1917
c_retval = virNetworkLookupByName(conn, name);
1918
LIBVIRT_END_ALLOW_THREADS;
1919
py_retval = libvirt_virNetworkPtrWrap((virNetworkPtr) c_retval);
1920
return(py_retval);
1921
}
1922
1923
PyObject *
1924
libvirt_virDomainGetMaxVcpus(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1925
PyObject *py_retval;
1926
int c_retval;
1927
virDomainPtr domain;
1928
PyObject *pyobj_domain;
1929
1930
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetMaxVcpus", &pyobj_domain))
1931
return(NULL);
1932
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1933
LIBVIRT_BEGIN_ALLOW_THREADS;
1934
1935
c_retval = virDomainGetMaxVcpus(domain);
1936
LIBVIRT_END_ALLOW_THREADS;
1937
py_retval = libvirt_intWrap((int) c_retval);
1938
return(py_retval);
1939
}
1940
1941
PyObject *
1942
libvirt_virDomainIsPersistent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1943
PyObject *py_retval;
1944
int c_retval;
1945
virDomainPtr dom;
1946
PyObject *pyobj_dom;
1947
1948
if (!PyArg_ParseTuple(args, (char *)"O:virDomainIsPersistent", &pyobj_dom))
1949
return(NULL);
1950
dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
1951
LIBVIRT_BEGIN_ALLOW_THREADS;
1952
1953
c_retval = virDomainIsPersistent(dom);
1954
LIBVIRT_END_ALLOW_THREADS;
1955
py_retval = libvirt_intWrap((int) c_retval);
1956
return(py_retval);
1957
}
1958
1959
PyObject *
1960
libvirt_virStreamEventUpdateCallback(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1961
PyObject *py_retval;
1962
int c_retval;
1963
virStreamPtr stream;
1964
PyObject *pyobj_stream;
1965
int events;
1966
1967
if (!PyArg_ParseTuple(args, (char *)"Oi:virStreamEventUpdateCallback", &pyobj_stream, &events))
1968
return(NULL);
1969
stream = (virStreamPtr) PyvirStream_Get(pyobj_stream);
1970
LIBVIRT_BEGIN_ALLOW_THREADS;
1971
1972
c_retval = virStreamEventUpdateCallback(stream, events);
1973
LIBVIRT_END_ALLOW_THREADS;
1974
py_retval = libvirt_intWrap((int) c_retval);
1975
return(py_retval);
1976
}
1977
1978
PyObject *
1979
libvirt_virNodeDeviceReset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1980
PyObject *py_retval;
1981
int c_retval;
1982
virNodeDevicePtr dev;
1983
PyObject *pyobj_dev;
1984
1985
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceReset", &pyobj_dev))
1986
return(NULL);
1987
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
1988
LIBVIRT_BEGIN_ALLOW_THREADS;
1989
1990
c_retval = virNodeDeviceReset(dev);
1991
LIBVIRT_END_ALLOW_THREADS;
1992
py_retval = libvirt_intWrap((int) c_retval);
1993
return(py_retval);
1994
}
1995
1996
PyObject *
1997
libvirt_virDomainDetachDevice(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1998
PyObject *py_retval;
1999
int c_retval;
2000
virDomainPtr domain;
2001
PyObject *pyobj_domain;
2002
char * xml;
2003
2004
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainDetachDevice", &pyobj_domain, &xml))
2005
return(NULL);
2006
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2007
LIBVIRT_BEGIN_ALLOW_THREADS;
2008
2009
c_retval = virDomainDetachDevice(domain, xml);
2010
LIBVIRT_END_ALLOW_THREADS;
2011
py_retval = libvirt_intWrap((int) c_retval);
2012
return(py_retval);
2013
}
2014
2015
PyObject *
2016
libvirt_virSecretGetUsageID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2017
PyObject *py_retval;
2018
const char * c_retval;
2019
virSecretPtr secret;
2020
PyObject *pyobj_secret;
2021
2022
if (!PyArg_ParseTuple(args, (char *)"O:virSecretGetUsageID", &pyobj_secret))
2023
return(NULL);
2024
secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
2025
LIBVIRT_BEGIN_ALLOW_THREADS;
2026
2027
c_retval = virSecretGetUsageID(secret);
2028
LIBVIRT_END_ALLOW_THREADS;
2029
py_retval = libvirt_charPtrConstWrap((const char *) c_retval);
2030
return(py_retval);
2031
}
2032
2033
PyObject *
2034
libvirt_virNodeDeviceReAttach(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2035
PyObject *py_retval;
2036
int c_retval;
2037
virNodeDevicePtr dev;
2038
PyObject *pyobj_dev;
2039
2040
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceReAttach", &pyobj_dev))
2041
return(NULL);
2042
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
2043
LIBVIRT_BEGIN_ALLOW_THREADS;
2044
2045
c_retval = virNodeDeviceReAttach(dev);
2046
LIBVIRT_END_ALLOW_THREADS;
2047
py_retval = libvirt_intWrap((int) c_retval);
2048
return(py_retval);
2049
}
2050
2051
PyObject *
2052
libvirt_virStoragePoolUndefine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2053
PyObject *py_retval;
2054
int c_retval;
2055
virStoragePoolPtr pool;
2056
PyObject *pyobj_pool;
2057
2058
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolUndefine", &pyobj_pool))
2059
return(NULL);
2060
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
2061
LIBVIRT_BEGIN_ALLOW_THREADS;
2062
2063
c_retval = virStoragePoolUndefine(pool);
2064
LIBVIRT_END_ALLOW_THREADS;
2065
py_retval = libvirt_intWrap((int) c_retval);
2066
return(py_retval);
2067
}
2068
2069
PyObject *
2070
libvirt_virDomainAttachDevice(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2071
PyObject *py_retval;
2072
int c_retval;
2073
virDomainPtr domain;
2074
PyObject *pyobj_domain;
2075
char * xml;
2076
2077
if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainAttachDevice", &pyobj_domain, &xml))
2078
return(NULL);
2079
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2080
LIBVIRT_BEGIN_ALLOW_THREADS;
2081
2082
c_retval = virDomainAttachDevice(domain, xml);
2083
LIBVIRT_END_ALLOW_THREADS;
2084
py_retval = libvirt_intWrap((int) c_retval);
2085
return(py_retval);
2086
}
2087
2088
PyObject *
2089
libvirt_virConnectGetURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2090
PyObject *py_retval;
2091
char * c_retval;
2092
virConnectPtr conn;
2093
PyObject *pyobj_conn;
2094
2095
if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetURI", &pyobj_conn))
2096
return(NULL);
2097
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2098
LIBVIRT_BEGIN_ALLOW_THREADS;
2099
2100
c_retval = virConnectGetURI(conn);
2101
LIBVIRT_END_ALLOW_THREADS;
2102
py_retval = libvirt_charPtrWrap((char *) c_retval);
2103
return(py_retval);
2104
}
2105
2106
PyObject *
2107
libvirt_virConnectOpenReadOnly(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2108
PyObject *py_retval;
2109
virConnectPtr c_retval;
2110
char * name;
2111
2112
if (!PyArg_ParseTuple(args, (char *)"z:virConnectOpenReadOnly", &name))
2113
return(NULL);
2114
LIBVIRT_BEGIN_ALLOW_THREADS;
2115
2116
c_retval = virConnectOpenReadOnly(name);
2117
LIBVIRT_END_ALLOW_THREADS;
2118
py_retval = libvirt_virConnectPtrWrap((virConnectPtr) c_retval);
2119
return(py_retval);
2120
}
2121
2122
PyObject *
2123
libvirt_virSecretDefineXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2124
PyObject *py_retval;
2125
virSecretPtr c_retval;
2126
virConnectPtr conn;
2127
PyObject *pyobj_conn;
2128
char * xml;
2129
unsigned int flags;
2130
2131
if (!PyArg_ParseTuple(args, (char *)"Ozi:virSecretDefineXML", &pyobj_conn, &xml, &flags))
2132
return(NULL);
2133
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2134
LIBVIRT_BEGIN_ALLOW_THREADS;
2135
2136
c_retval = virSecretDefineXML(conn, xml, flags);
2137
LIBVIRT_END_ALLOW_THREADS;
2138
py_retval = libvirt_virSecretPtrWrap((virSecretPtr) c_retval);
2139
return(py_retval);
2140
}
2141
2142
PyObject *
2143
libvirt_virNetworkFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2144
PyObject *py_retval;
2145
int c_retval;
2146
virNetworkPtr network;
2147
PyObject *pyobj_network;
2148
2149
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkFree", &pyobj_network))
2150
return(NULL);
2151
network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
2152
LIBVIRT_BEGIN_ALLOW_THREADS;
2153
2154
c_retval = virNetworkFree(network);
2155
LIBVIRT_END_ALLOW_THREADS;
2156
py_retval = libvirt_intWrap((int) c_retval);
2157
return(py_retval);
2158
}
2159
2160
PyObject *
2161
libvirt_virStorageVolDelete(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2162
PyObject *py_retval;
2163
int c_retval;
2164
virStorageVolPtr vol;
2165
PyObject *pyobj_vol;
2166
unsigned int flags;
2167
2168
if (!PyArg_ParseTuple(args, (char *)"Oi:virStorageVolDelete", &pyobj_vol, &flags))
2169
return(NULL);
2170
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
2171
LIBVIRT_BEGIN_ALLOW_THREADS;
2172
2173
c_retval = virStorageVolDelete(vol, flags);
2174
LIBVIRT_END_ALLOW_THREADS;
2175
py_retval = libvirt_intWrap((int) c_retval);
2176
return(py_retval);
2177
}
2178
2179
PyObject *
2180
libvirt_virInterfaceFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2181
PyObject *py_retval;
2182
int c_retval;
2183
virInterfacePtr iface;
2184
PyObject *pyobj_iface;
2185
2186
if (!PyArg_ParseTuple(args, (char *)"O:virInterfaceFree", &pyobj_iface))
2187
return(NULL);
2188
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
2189
LIBVIRT_BEGIN_ALLOW_THREADS;
2190
2191
c_retval = virInterfaceFree(iface);
2192
LIBVIRT_END_ALLOW_THREADS;
2193
py_retval = libvirt_intWrap((int) c_retval);
2194
return(py_retval);
2195
}
2196
2197
PyObject *
2198
libvirt_virNodeDeviceNumOfCaps(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2199
PyObject *py_retval;
2200
int c_retval;
2201
virNodeDevicePtr dev;
2202
PyObject *pyobj_dev;
2203
2204
if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceNumOfCaps", &pyobj_dev))
2205
return(NULL);
2206
dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
2207
LIBVIRT_BEGIN_ALLOW_THREADS;
2208
2209
c_retval = virNodeDeviceNumOfCaps(dev);
2210
LIBVIRT_END_ALLOW_THREADS;
2211
py_retval = libvirt_intWrap((int) c_retval);
2212
return(py_retval);
2213
}
2214
2215
PyObject *
2216
libvirt_virInterfaceLookupByMACString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2217
PyObject *py_retval;
2218
virInterfacePtr c_retval;
2219
virConnectPtr conn;
2220
PyObject *pyobj_conn;
2221
char * macstr;
2222
2223
if (!PyArg_ParseTuple(args, (char *)"Oz:virInterfaceLookupByMACString", &pyobj_conn, &macstr))
2224
return(NULL);
2225
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2226
LIBVIRT_BEGIN_ALLOW_THREADS;
2227
2228
c_retval = virInterfaceLookupByMACString(conn, macstr);
2229
LIBVIRT_END_ALLOW_THREADS;
2230
py_retval = libvirt_virInterfacePtrWrap((virInterfacePtr) c_retval);
2231
return(py_retval);
2232
}
2233
2234
PyObject *
2235
libvirt_virNodeGetFreeMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2236
PyObject *py_retval;
2237
unsigned long long c_retval;
2238
virConnectPtr conn;
2239
PyObject *pyobj_conn;
2240
2241
if (!PyArg_ParseTuple(args, (char *)"O:virNodeGetFreeMemory", &pyobj_conn))
2242
return(NULL);
2243
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2244
LIBVIRT_BEGIN_ALLOW_THREADS;
2245
2246
c_retval = virNodeGetFreeMemory(conn);
2247
LIBVIRT_END_ALLOW_THREADS;
2248
py_retval = libvirt_longlongWrap((long long) c_retval);
2249
return(py_retval);
2250
}
2251
2252
PyObject *
2253
libvirt_virInterfaceDestroy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2254
PyObject *py_retval;
2255
int c_retval;
2256
virInterfacePtr iface;
2257
PyObject *pyobj_iface;
2258
unsigned int flags;
2259
2260
if (!PyArg_ParseTuple(args, (char *)"Oi:virInterfaceDestroy", &pyobj_iface, &flags))
2261
return(NULL);
2262
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
2263
LIBVIRT_BEGIN_ALLOW_THREADS;
2264
2265
c_retval = virInterfaceDestroy(iface, flags);
2266
LIBVIRT_END_ALLOW_THREADS;
2267
py_retval = libvirt_intWrap((int) c_retval);
2268
return(py_retval);
2269
}
2270
2271
PyObject *
2272
libvirt_virNodeNumOfDevices(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2273
PyObject *py_retval;
2274
int c_retval;
2275
virConnectPtr conn;
2276
PyObject *pyobj_conn;
2277
char * cap;
2278
unsigned int flags;
2279
2280
if (!PyArg_ParseTuple(args, (char *)"Ozi:virNodeNumOfDevices", &pyobj_conn, &cap, &flags))
2281
return(NULL);
2282
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2283
LIBVIRT_BEGIN_ALLOW_THREADS;
2284
2285
c_retval = virNodeNumOfDevices(conn, cap, flags);
2286
LIBVIRT_END_ALLOW_THREADS;
2287
py_retval = libvirt_intWrap((int) c_retval);
2288
return(py_retval);
2289
}
2290
2291
PyObject *
2292
libvirt_virStoragePoolDestroy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2293
PyObject *py_retval;
2294
int c_retval;
2295
virStoragePoolPtr pool;
2296
PyObject *pyobj_pool;
2297
2298
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolDestroy", &pyobj_pool))
2299
return(NULL);
2300
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
2301
LIBVIRT_BEGIN_ALLOW_THREADS;
2302
2303
c_retval = virStoragePoolDestroy(pool);
2304
LIBVIRT_END_ALLOW_THREADS;
2305
py_retval = libvirt_intWrap((int) c_retval);
2306
return(py_retval);
2307
}
2308
2309
PyObject *
2310
libvirt_virStoragePoolLookupByVolume(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2311
PyObject *py_retval;
2312
virStoragePoolPtr c_retval;
2313
virStorageVolPtr vol;
2314
PyObject *pyobj_vol;
2315
2316
if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolLookupByVolume", &pyobj_vol))
2317
return(NULL);
2318
vol = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_vol);
2319
LIBVIRT_BEGIN_ALLOW_THREADS;
2320
2321
c_retval = virStoragePoolLookupByVolume(vol);
2322
LIBVIRT_END_ALLOW_THREADS;
2323
py_retval = libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
2324
return(py_retval);
2325
}
2326
2327
PyObject *
2328
libvirt_virDomainGetOSType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2329
PyObject *py_retval;
2330
char * c_retval;
2331
virDomainPtr domain;
2332
PyObject *pyobj_domain;
2333
2334
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetOSType", &pyobj_domain))
2335
return(NULL);
2336
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2337
LIBVIRT_BEGIN_ALLOW_THREADS;
2338
2339
c_retval = virDomainGetOSType(domain);
2340
LIBVIRT_END_ALLOW_THREADS;
2341
py_retval = libvirt_charPtrWrap((char *) c_retval);
2342
return(py_retval);
2343
}
2344
2345
PyObject *
2346
libvirt_virStoragePoolBuild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2347
PyObject *py_retval;
2348
int c_retval;
2349
virStoragePoolPtr pool;
2350
PyObject *pyobj_pool;
2351
unsigned int flags;
2352
2353
if (!PyArg_ParseTuple(args, (char *)"Oi:virStoragePoolBuild", &pyobj_pool, &flags))
2354
return(NULL);
2355
pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
2356
LIBVIRT_BEGIN_ALLOW_THREADS;
2357
2358
c_retval = virStoragePoolBuild(pool, flags);
2359
LIBVIRT_END_ALLOW_THREADS;
2360
py_retval = libvirt_intWrap((int) c_retval);
2361
return(py_retval);
2362
}
2363
2364
PyObject *
2365
libvirt_virDomainSetAutostart(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2366
PyObject *py_retval;
2367
int c_retval;
2368
virDomainPtr domain;
2369
PyObject *pyobj_domain;
2370
int autostart;
2371
2372
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainSetAutostart", &pyobj_domain, &autostart))
2373
return(NULL);
2374
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2375
LIBVIRT_BEGIN_ALLOW_THREADS;
2376
2377
c_retval = virDomainSetAutostart(domain, autostart);
2378
LIBVIRT_END_ALLOW_THREADS;
2379
py_retval = libvirt_intWrap((int) c_retval);
2380
return(py_retval);
2381
}
2382
2383
PyObject *
2384
libvirt_virDomainMigrate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2385
PyObject *py_retval;
2386
virDomainPtr c_retval;
2387
virDomainPtr domain;
2388
PyObject *pyobj_domain;
2389
virConnectPtr dconn;
2390
PyObject *pyobj_dconn;
2391
unsigned long flags;
2392
char * dname;
2393
char * uri;
2394
unsigned long bandwidth;
2395
2396
if (!PyArg_ParseTuple(args, (char *)"OOlzzl:virDomainMigrate", &pyobj_domain, &pyobj_dconn, &flags, &dname, &uri, &bandwidth))
2397
return(NULL);
2398
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2399
dconn = (virConnectPtr) PyvirConnect_Get(pyobj_dconn);
2400
LIBVIRT_BEGIN_ALLOW_THREADS;
2401
2402
c_retval = virDomainMigrate(domain, dconn, flags, dname, uri, bandwidth);
2403
LIBVIRT_END_ALLOW_THREADS;
2404
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
2405
return(py_retval);
2406
}
2407
2408
PyObject *
2409
libvirt_virConnectNumOfDefinedStoragePools(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2410
PyObject *py_retval;
2411
int c_retval;
2412
virConnectPtr conn;
2413
PyObject *pyobj_conn;
2414
2415
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfDefinedStoragePools", &pyobj_conn))
2416
return(NULL);
2417
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2418
LIBVIRT_BEGIN_ALLOW_THREADS;
2419
2420
c_retval = virConnectNumOfDefinedStoragePools(conn);
2421
LIBVIRT_END_ALLOW_THREADS;
2422
py_retval = libvirt_intWrap((int) c_retval);
2423
return(py_retval);
2424
}
2425
2426
PyObject *
2427
libvirt_virSecretFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2428
PyObject *py_retval;
2429
int c_retval;
2430
virSecretPtr secret;
2431
PyObject *pyobj_secret;
2432
2433
if (!PyArg_ParseTuple(args, (char *)"O:virSecretFree", &pyobj_secret))
2434
return(NULL);
2435
secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
2436
LIBVIRT_BEGIN_ALLOW_THREADS;
2437
2438
c_retval = virSecretFree(secret);
2439
LIBVIRT_END_ALLOW_THREADS;
2440
py_retval = libvirt_intWrap((int) c_retval);
2441
return(py_retval);
2442
}
2443
2444
PyObject *
2445
libvirt_virStreamFinish(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2446
PyObject *py_retval;
2447
int c_retval;
2448
virStreamPtr stream;
2449
PyObject *pyobj_stream;
2450
2451
if (!PyArg_ParseTuple(args, (char *)"O:virStreamFinish", &pyobj_stream))
2452
return(NULL);
2453
stream = (virStreamPtr) PyvirStream_Get(pyobj_stream);
2454
LIBVIRT_BEGIN_ALLOW_THREADS;
2455
2456
c_retval = virStreamFinish(stream);
2457
LIBVIRT_END_ALLOW_THREADS;
2458
py_retval = libvirt_intWrap((int) c_retval);
2459
return(py_retval);
2460
}
2461
2462
PyObject *
2463
libvirt_virNetworkIsActive(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2464
PyObject *py_retval;
2465
int c_retval;
2466
virNetworkPtr net;
2467
PyObject *pyobj_net;
2468
2469
if (!PyArg_ParseTuple(args, (char *)"O:virNetworkIsActive", &pyobj_net))
2470
return(NULL);
2471
net = (virNetworkPtr) PyvirNetwork_Get(pyobj_net);
2472
LIBVIRT_BEGIN_ALLOW_THREADS;
2473
2474
c_retval = virNetworkIsActive(net);
2475
LIBVIRT_END_ALLOW_THREADS;
2476
py_retval = libvirt_intWrap((int) c_retval);
2477
return(py_retval);
2478
}
2479
2480
PyObject *
2481
libvirt_virConnectOpen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2482
PyObject *py_retval;
2483
virConnectPtr c_retval;
2484
char * name;
2485
2486
if (!PyArg_ParseTuple(args, (char *)"z:virConnectOpen", &name))
2487
return(NULL);
2488
LIBVIRT_BEGIN_ALLOW_THREADS;
2489
2490
c_retval = virConnectOpen(name);
2491
LIBVIRT_END_ALLOW_THREADS;
2492
py_retval = libvirt_virConnectPtrWrap((virConnectPtr) c_retval);
2493
return(py_retval);
2494
}
2495
2496
PyObject *
2497
libvirt_virDomainCreateXML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2498
PyObject *py_retval;
2499
virDomainPtr c_retval;
2500
virConnectPtr conn;
2501
PyObject *pyobj_conn;
2502
char * xmlDesc;
2503
unsigned int flags;
2504
2505
if (!PyArg_ParseTuple(args, (char *)"Ozi:virDomainCreateXML", &pyobj_conn, &xmlDesc, &flags))
2506
return(NULL);
2507
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2508
LIBVIRT_BEGIN_ALLOW_THREADS;
2509
2510
c_retval = virDomainCreateXML(conn, xmlDesc, flags);
2511
LIBVIRT_END_ALLOW_THREADS;
2512
py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
2513
return(py_retval);
2514
}
2515
2516
PyObject *
2517
libvirt_virStreamEventRemoveCallback(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2518
PyObject *py_retval;
2519
int c_retval;
2520
virStreamPtr stream;
2521
PyObject *pyobj_stream;
2522
2523
if (!PyArg_ParseTuple(args, (char *)"O:virStreamEventRemoveCallback", &pyobj_stream))
2524
return(NULL);
2525
stream = (virStreamPtr) PyvirStream_Get(pyobj_stream);
2526
LIBVIRT_BEGIN_ALLOW_THREADS;
2527
2528
c_retval = virStreamEventRemoveCallback(stream);
2529
LIBVIRT_END_ALLOW_THREADS;
2530
py_retval = libvirt_intWrap((int) c_retval);
2531
return(py_retval);
2532
}
2533
2534
PyObject *
2535
libvirt_virInterfaceIsActive(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2536
PyObject *py_retval;
2537
int c_retval;
2538
virInterfacePtr iface;
2539
PyObject *pyobj_iface;
2540
2541
if (!PyArg_ParseTuple(args, (char *)"O:virInterfaceIsActive", &pyobj_iface))
2542
return(NULL);
2543
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
2544
LIBVIRT_BEGIN_ALLOW_THREADS;
2545
2546
c_retval = virInterfaceIsActive(iface);
2547
LIBVIRT_END_ALLOW_THREADS;
2548
py_retval = libvirt_intWrap((int) c_retval);
2549
return(py_retval);
2550
}
2551
2552
PyObject *
2553
libvirt_virInterfaceUndefine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2554
PyObject *py_retval;
2555
int c_retval;
2556
virInterfacePtr iface;
2557
PyObject *pyobj_iface;
2558
2559
if (!PyArg_ParseTuple(args, (char *)"O:virInterfaceUndefine", &pyobj_iface))
2560
return(NULL);
2561
iface = (virInterfacePtr) PyvirInterface_Get(pyobj_iface);
2562
LIBVIRT_BEGIN_ALLOW_THREADS;
2563
2564
c_retval = virInterfaceUndefine(iface);
2565
LIBVIRT_END_ALLOW_THREADS;
2566
py_retval = libvirt_intWrap((int) c_retval);
2567
return(py_retval);
2568
}
2569
2570
PyObject *
2571
libvirt_virDomainSetVcpus(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2572
PyObject *py_retval;
2573
int c_retval;
2574
virDomainPtr domain;
2575
PyObject *pyobj_domain;
2576
unsigned int nvcpus;
2577
2578
if (!PyArg_ParseTuple(args, (char *)"Oi:virDomainSetVcpus", &pyobj_domain, &nvcpus))
2579
return(NULL);
2580
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2581
LIBVIRT_BEGIN_ALLOW_THREADS;
2582
2583
c_retval = virDomainSetVcpus(domain, nvcpus);
2584
LIBVIRT_END_ALLOW_THREADS;
2585
py_retval = libvirt_intWrap((int) c_retval);
2586
return(py_retval);
2587
}
2588
2589
PyObject *
2590
libvirt_virConnectNumOfInterfaces(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2591
PyObject *py_retval;
2592
int c_retval;
2593
virConnectPtr conn;
2594
PyObject *pyobj_conn;
2595
2596
if (!PyArg_ParseTuple(args, (char *)"O:virConnectNumOfInterfaces", &pyobj_conn))
2597
return(NULL);
2598
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2599
LIBVIRT_BEGIN_ALLOW_THREADS;
2600
2601
c_retval = virConnectNumOfInterfaces(conn);
2602
LIBVIRT_END_ALLOW_THREADS;
2603
py_retval = libvirt_intWrap((int) c_retval);
2604
return(py_retval);
2605
}
2606
2607
PyObject *
2608
libvirt_virDomainGetID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2609
PyObject *py_retval;
2610
unsigned int c_retval;
2611
virDomainPtr domain;
2612
PyObject *pyobj_domain;
2613
2614
if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetID", &pyobj_domain))
2615
return(NULL);
2616
domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2617
LIBVIRT_BEGIN_ALLOW_THREADS;
2618
2619
c_retval = virDomainGetID(domain);
2620
LIBVIRT_END_ALLOW_THREADS;
2621
py_retval = libvirt_intWrap((int) c_retval);
2622
return(py_retval);
2623
}
2624
2625
PyObject *
2626
libvirt_virConnectIsEncrypted(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2627
PyObject *py_retval;
2628
int c_retval;
2629
virConnectPtr conn;
2630
PyObject *pyobj_conn;
2631
2632
if (!PyArg_ParseTuple(args, (char *)"O:virConnectIsEncrypted", &pyobj_conn))
2633
return(NULL);
2634
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2635
LIBVIRT_BEGIN_ALLOW_THREADS;
2636
2637
c_retval = virConnectIsEncrypted(conn);
2638
LIBVIRT_END_ALLOW_THREADS;
2639
py_retval = libvirt_intWrap((int) c_retval);
2640
return(py_retval);
2641
}
2642
2643
PyObject *
2644
libvirt_virInterfaceLookupByName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2645
PyObject *py_retval;
2646
virInterfacePtr c_retval;
2647
virConnectPtr conn;
2648
PyObject *pyobj_conn;
2649
char * name;
2650
2651
if (!PyArg_ParseTuple(args, (char *)"Oz:virInterfaceLookupByName", &pyobj_conn, &name))
2652
return(NULL);
2653
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2654
LIBVIRT_BEGIN_ALLOW_THREADS;
2655
2656
c_retval = virInterfaceLookupByName(conn, name);
2657
LIBVIRT_END_ALLOW_THREADS;
2658
py_retval = libvirt_virInterfacePtrWrap((virInterfacePtr) c_retval);
2659
return(py_retval);
2660
}
2661
2662
PyObject *
2663
libvirt_virStorageVolLookupByKey(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2664
PyObject *py_retval;
2665
virStorageVolPtr c_retval;
2666
virConnectPtr conn;
2667
PyObject *pyobj_conn;
2668
char * key;
2669
2670
if (!PyArg_ParseTuple(args, (char *)"Oz:virStorageVolLookupByKey", &pyobj_conn, &key))
2671
return(NULL);
2672
conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2673
LIBVIRT_BEGIN_ALLOW_THREADS;
2674
2675
c_retval = virStorageVolLookupByKey(conn, key);
2676
LIBVIRT_END_ALLOW_THREADS;
2677
py_retval = libvirt_virStorageVolPtrWrap((virStorageVolPtr) c_retval);
2678
return(py_retval);
2679
}
2680
Loggerhead is a web-based interface for Breezy
Version: 2.0.1