extras/python/statgrab.pyx

#
# i-scream central monitoring system
# http://www.i-scream.org
# Copyright (C) 2000-2004 i-scream
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
# $Id: statgrab.pyx,v 1.9 2004/03/06 22:11:22 tdb Exp $
#

ctypedef long time_t

cdef extern from "statgrab.h":
    ctypedef struct cpu_states_t:
        long long user
        long long kernel
        long long idle
        long long iowait
        long long swap
        long long nice
        long long total
        time_t systime

    ctypedef struct cpu_percent_t:
        float user
        float kernel
        float idle
        float iowait
        float swap
        float nice
        time_t time_taken

    ctypedef struct mem_stat_t:
        long long total
        long long free
        long long used
        long long cache

    ctypedef struct load_stat_t:
        double min1
        double min5
        double min15

    ctypedef struct user_stat_t:
        char *name_list
        int num_entries

    ctypedef struct swap_stat_t:
        long long total
        long long used
        long long free

    ctypedef struct general_stat_t:
        char *os_name
        char *os_release
        char *os_version
        char *platform
        char *hostname
        time_t uptime

    ctypedef struct disk_stat_t:
        char *device_name
        char *fs_type
        char *mnt_point
        long long size
        long long used
        long long avail
        long long total_inodes
        long long used_inodes
        long long free_inodes

    ctypedef struct diskio_stat_t:
        char *disk_name
        long long read_bytes
        long long write_bytes
        time_t systime

    ctypedef struct process_stat_t:
        int total
        int running
        int sleeping
        int stopped
        int zombie

    ctypedef struct network_stat_t:
        char *interface_name
        long long tx
        long long rx
        long long ipackets
        long long opackets
        long long ierrors
        long long oerrors
        long long collisions
        time_t systime

    ctypedef enum statgrab_duplex:
        FULL_DUPLEX
        HALF_DUPLEX
        UNKNOWN_DUPLEX

    ctypedef struct network_iface_stat_t:
        char *interface_name
        int speed
        statgrab_duplex dup
        int up

    ctypedef struct page_stat_t:
        long long pages_pagein
        long long pages_pageout
        time_t systime

    cdef extern cpu_states_t *get_cpu_totals()
    cdef extern cpu_states_t *get_cpu_diff()
    cdef extern cpu_percent_t *cpu_percent_usage()
    cdef extern mem_stat_t *get_memory_stats()
    cdef extern load_stat_t *get_load_stats()
    cdef extern user_stat_t *get_user_stats()
    cdef extern swap_stat_t *get_swap_stats()
    cdef extern general_stat_t *get_general_stats()
    cdef extern disk_stat_t *get_disk_stats(int *entries)
    cdef extern diskio_stat_t *get_diskio_stats(int *entries)
    cdef extern diskio_stat_t *get_diskio_stats_diff(int *entries)
    cdef extern process_stat_t *get_process_stats()
    cdef extern network_stat_t *get_network_stats(int *entries)
    cdef extern network_stat_t *get_network_stats_diff(int *entries)
    cdef extern network_iface_stat_t *get_network_iface_stats(int *entries)
    cdef extern page_stat_t *get_page_stats()
    cdef extern page_stat_t *get_page_stats_diff()
    cdef extern int statgrab_init()
    cdef extern int statgrab_drop_privileges()


py_FULL_DUPLEX = FULL_DUPLEX
py_HALF_DUPLEX = HALF_DUPLEX
py_UNKNOWN_DUPLEX = UNKNOWN_DUPLEX


class Result:
    def __init__(self, attrs):
        self.attrs = attrs
        for attr in attrs:
            setattr(self, attr, attrs[attr])
    def __getitem__(self, item):
        return getattr(self, item)
    def __repr__(self):
        return str(self.attrs)

class StatgrabException(Exception):
    def __init__(self, value):
        self.value = value
    def __str__(self):
        return repr(self.value)


def py_get_cpu_totals():
    cdef cpu_states_t *s
    s = get_cpu_totals()
    if s == NULL:
        raise StatgrabException, 'get_cpu_totals() returned NULL'
    return Result(
        {'user': s.user,
         'kernel': s.kernel,
         'idle': s.idle,
         'iowait': s.iowait,
         'swap': s.swap,
         'nice': s.nice,
         'total': s.total,
         'systime': s.systime,
        }
    )

def py_get_cpu_diff():
    cdef cpu_states_t *s
    s = get_cpu_diff()
    if s == NULL:
        raise StatgrabException, 'get_cpu_diff() returned NULL'
    return Result(
        {'user': s.user,
         'kernel': s.kernel,
         'idle': s.idle,
         'iowait': s.iowait,
         'swap': s.swap,
         'nice': s.nice,
         'total': s.total,
         'systime': s.systime,
        }
    )

def py_cpu_percent_usage():
    cdef cpu_percent_t *s
    s = cpu_percent_usage()
    if s == NULL:
        raise StatgrabException, 'cpu_percent_usage() returned NULL'
    return Result(
        {'user': s.user,
         'kernel': s.kernel,
         'idle': s.idle,
         'iowait': s.iowait,
         'swap': s.swap,
         'nice': s.nice,
         'time_taken': s.time_taken,
        }
    )

def py_get_memory_stats():
    cdef mem_stat_t *s
    s = get_memory_stats()
    if s == NULL:
        raise StatgrabException, 'get_memory_stats() returned NULL'
    return Result(
        {'total': s.total,
         'used': s.used,
         'free': s.free,
         'cache': s.cache,
        }
    )

def py_get_load_stats():
    cdef load_stat_t *s
    s = get_load_stats()
    if s == NULL:
        raise StatgrabException, 'get_load_stats() returned NULL'
    return Result(
        {'min1': s.min1,
         'min5': s.min5,
         'min15': s.min15,
        }
    )

def py_get_user_stats():
    cdef user_stat_t *s
    s = get_user_stats()
    if s == NULL:
        raise StatgrabException, 'get_user_stats() returned NULL'
    return Result(
        {'name_list': s.name_list,
         'num_entries': s.num_entries,
        }
    )

def py_get_swap_stats():
    cdef swap_stat_t *s
    s = get_swap_stats()
    if s == NULL:
        raise StatgrabException, 'get_swap_stats() returned NULL'
    return Result(
        {'total': s.total,
         'used': s.used,
         'free': s.free,
        }
    )

def py_get_general_stats():
    cdef general_stat_t *s
    s = get_general_stats()
    if s == NULL:
        raise StatgrabException, 'get_general_stats() returned NULL'
    return Result(
        {'os_name': s.os_name,
         'os_release': s.os_release,
         'os_version': s.os_version,
         'platform': s.platform,
         'hostname': s.hostname,
         'uptime': s.uptime,
        }
    )

def py_get_disk_stats():
    cdef disk_stat_t *s
    cdef int entries
    s = get_disk_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'get_disk_stats() returned NULL'
    list = []
    for i from 0 <= i < entries:
        list.append(Result(
            {'device_name': s.device_name,
             'fs_type': s.fs_type,
             'mnt_point': s.mnt_point,
             'size': s.size,
             'used': s.used,
             'avail': s.avail,
             'total_inodes': s.total_inodes,
             'used_inodes': s.used_inodes,
             'free_inodes': s.free_inodes,
            }
        ))
        s = s + 1
    return list

def py_get_diskio_stats():
    cdef diskio_stat_t *s
    cdef int entries
    s = get_diskio_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'get_diskio_stats() returned NULL'
    list = []
    for i from 0 <= i < entries:
        list.append(Result(
            {'disk_name': s.disk_name,
             'read_bytes': s.read_bytes,
             'write_bytes': s.write_bytes,
             'systime': s.systime,
            }
        ))
        s = s + 1
    return list

def py_get_diskio_stats_diff():
    cdef diskio_stat_t *s
    cdef int entries
    s = get_diskio_stats_diff(&entries)
    if s == NULL:
        raise StatgrabException, 'get_diskio_stats_diff() returned NULL'
    list = []
    for i from 0 <= i < entries:
        list.append(Result(
            {'disk_name': s.disk_name,
             'read_bytes': s.read_bytes,
             'write_bytes': s.write_bytes,
             'systime': s.systime,
            }
        ))
        s = s + 1
    return list

def py_get_process_stats():
    cdef process_stat_t *s
    s = get_process_stats()
    if s == NULL:
        raise StatgrabException, 'get_process_stats() returned NULL'
    return Result(
        {'total': s.total,
         'running': s.running,
         'sleeping': s.sleeping,
         'stopped': s.stopped,
         'zombie': s.zombie,
        }
    )

def py_get_network_stats():
    cdef network_stat_t *s
    cdef int entries
    s = get_network_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'get_network_stats() returned NULL'
    list = []
    for i from 0 <= i < entries:
        list.append(Result(
            {'interface_name': s.interface_name,
             'tx': s.tx,
             'rx': s.rx,
             'ipackets': s.ipackets,
             'opackets': s.opackets,
             'ierrors': s.ierrors,
             'oerrors': s.oerrors,
             'collisions': s.collisions,
             'systime': s.systime,
            }
        ))
        s = s + 1
    return list

def py_get_network_stats_diff():
    cdef network_stat_t *s
    cdef int entries
    s = get_network_stats_diff(&entries)
    if s == NULL:
        raise StatgrabException, 'get_network_stats_diff() returned NULL'
    list = []
    for i from 0 <= i < entries:
        list.append(Result(
            {'interface_name': s.interface_name,
             'tx': s.tx,
             'rx': s.rx,
             'ipackets': s.ipackets,
             'opackets': s.opackets,
             'ierrors': s.ierrors,
             'oerrors': s.oerrors,
             'collisions': s.collisions,
             'systime': s.systime,
            }
        ))
        s = s + 1
    return list

def py_get_network_iface_stats():
    cdef network_iface_stat_t *s
    cdef int entries
    s = get_network_iface_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'get_network_iface_stats() returned NULL'
    list = []
    for i from 0 <= i < entries:
        list.append(Result(
            {'interface_name': s.interface_name,
             'speed': s.speed,
             'dup': s.dup,
             'up' : s.up,
            }
        ))
        s = s + 1
    return list

def py_get_page_stats():
    cdef page_stat_t *s
    s = get_page_stats()
    if s == NULL:
        raise StatgrabException, 'get_page_stats() returned NULL'
    return Result(
        {'pages_pagein': s.pages_pagein,
         'pages_pageout': s.pages_pageout,
        }
    )

def py_get_page_stats_diff():
    cdef page_stat_t *s
    s = get_page_stats_diff()
    if s == NULL:
        raise StatgrabException, 'get_page_stats_diff() returned NULL'
    return Result(
        {'pages_pagein': s.pages_pagein,
         'pages_pageout': s.pages_pageout,
        }
    )

def py_statgrab_init():
    return statgrab_init()

def py_statgrab_drop_privileges():
    return statgrab_drop_privileges()
Revision:	1.10
Committed:	Sat Mar 20 19:25:19 2004 UTC (20 years, 9 months ago) by tdb
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.9:	+1 -1 lines
State:	*FILE REMOVED*
Log Message:	The libstatgrab python bindings are now their own package - pystatgrab.
#	User	Rev	Content
1	tdb	1.3	#
2			# i-scream central monitoring system
3			# http://www.i-scream.org
4			# Copyright (C) 2000-2004 i-scream
5			#
6			# This program is free software; you can redistribute it and/or
7			# modify it under the terms of the GNU General Public License
8			# as published by the Free Software Foundation; either version 2
9			# of the License, or (at your option) any later version.
10			#
11			# This program is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with this program; if not, write to the Free Software
18			# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19			#
20	tdb	1.10	# $Id: statgrab.pyx,v 1.9 2004/03/06 22:11:22 tdb Exp $
21	tdb	1.3	#
22	tdb	1.1
23			ctypedef long time_t
24
25			cdef extern from "statgrab.h":
26			ctypedef struct cpu_states_t:
27			long long user
28			long long kernel
29			long long idle
30			long long iowait
31			long long swap
32			long long nice
33			long long total
34			time_t systime
35
36			ctypedef struct cpu_percent_t:
37			float user
38			float kernel
39			float idle
40			float iowait
41			float swap
42			float nice
43			time_t time_taken
44
45			ctypedef struct mem_stat_t:
46			long long total
47			long long free
48			long long used
49			long long cache
50
51			ctypedef struct load_stat_t:
52			double min1
53			double min5
54			double min15
55
56			ctypedef struct user_stat_t:
57			char *name_list
58			int num_entries
59
60			ctypedef struct swap_stat_t:
61			long long total
62			long long used
63			long long free
64
65			ctypedef struct general_stat_t:
66			char *os_name
67			char *os_release
68			char *os_version
69			char *platform
70			char *hostname
71			time_t uptime
72
73			ctypedef struct disk_stat_t:
74			char *device_name
75			char *fs_type
76			char *mnt_point
77			long long size
78			long long used
79			long long avail
80			long long total_inodes
81			long long used_inodes
82			long long free_inodes
83
84			ctypedef struct diskio_stat_t:
85			char *disk_name
86			long long read_bytes
87			long long write_bytes
88			time_t systime
89
90			ctypedef struct process_stat_t:
91			int total
92			int running
93			int sleeping
94			int stopped
95			int zombie
96
97			ctypedef struct network_stat_t:
98			char *interface_name
99			long long tx
100			long long rx
101	tdb	1.9	long long ipackets
102			long long opackets
103			long long ierrors
104			long long oerrors
105			long long collisions
106	tdb	1.1	time_t systime
107
108	tdb	1.7	ctypedef enum statgrab_duplex:
109	tdb	1.5	FULL_DUPLEX
110			HALF_DUPLEX
111	tdb	1.7	UNKNOWN_DUPLEX
112	tdb	1.5
113			ctypedef struct network_iface_stat_t:
114			char *interface_name
115			int speed
116	tdb	1.7	statgrab_duplex dup
117	tdb	1.8	int up
118	tdb	1.5
119	tdb	1.1	ctypedef struct page_stat_t:
120			long long pages_pagein
121			long long pages_pageout
122			time_t systime
123
124			cdef extern cpu_states_t *get_cpu_totals()
125			cdef extern cpu_states_t *get_cpu_diff()
126			cdef extern cpu_percent_t *cpu_percent_usage()
127			cdef extern mem_stat_t *get_memory_stats()
128			cdef extern load_stat_t *get_load_stats()
129			cdef extern user_stat_t *get_user_stats()
130			cdef extern swap_stat_t *get_swap_stats()
131			cdef extern general_stat_t *get_general_stats()
132			cdef extern disk_stat_t get_disk_stats(int entries)
133			cdef extern diskio_stat_t get_diskio_stats(int entries)
134			cdef extern diskio_stat_t get_diskio_stats_diff(int entries)
135			cdef extern process_stat_t *get_process_stats()
136			cdef extern network_stat_t get_network_stats(int entries)
137			cdef extern network_stat_t get_network_stats_diff(int entries)
138	tdb	1.5	cdef extern network_iface_stat_t get_network_iface_stats(int entries)
139	tdb	1.1	cdef extern page_stat_t *get_page_stats()
140			cdef extern page_stat_t *get_page_stats_diff()
141			cdef extern int statgrab_init()
142			cdef extern int statgrab_drop_privileges()
143	tdb	1.7
144
145			py_FULL_DUPLEX = FULL_DUPLEX
146			py_HALF_DUPLEX = HALF_DUPLEX
147			py_UNKNOWN_DUPLEX = UNKNOWN_DUPLEX
148	tdb	1.1
149
150	tdb	1.2	class Result:
151			def __init__(self, attrs):
152			self.attrs = attrs
153			for attr in attrs:
154			setattr(self, attr, attrs[attr])
155			def __getitem__(self, item):
156			return getattr(self, item)
157			def __repr__(self):
158			return str(self.attrs)
159
160	tdb	1.4	class StatgrabException(Exception):
161	tdb	1.3	def __init__(self, value):
162			self.value = value
163			def __str__(self):
164			return repr(self.value)
165
166	tdb	1.2
167	tdb	1.1	def py_get_cpu_totals():
168			cdef cpu_states_t *s
169			s = get_cpu_totals()
170	tdb	1.3	if s == NULL:
171			raise StatgrabException, 'get_cpu_totals() returned NULL'
172	tdb	1.2	return Result(
173			{'user': s.user,
174			'kernel': s.kernel,
175			'idle': s.idle,
176			'iowait': s.iowait,
177			'swap': s.swap,
178			'nice': s.nice,
179			'total': s.total,
180			'systime': s.systime,
181			}
182			)
183	tdb	1.1
184			def py_get_cpu_diff():
185			cdef cpu_states_t *s
186			s = get_cpu_diff()
187	tdb	1.3	if s == NULL:
188			raise StatgrabException, 'get_cpu_diff() returned NULL'
189	tdb	1.2	return Result(
190			{'user': s.user,
191			'kernel': s.kernel,
192			'idle': s.idle,
193			'iowait': s.iowait,
194			'swap': s.swap,
195			'nice': s.nice,
196			'total': s.total,
197			'systime': s.systime,
198			}
199			)
200	tdb	1.1
201			def py_cpu_percent_usage():
202			cdef cpu_percent_t *s
203			s = cpu_percent_usage()
204	tdb	1.3	if s == NULL:
205			raise StatgrabException, 'cpu_percent_usage() returned NULL'
206	tdb	1.2	return Result(
207			{'user': s.user,
208			'kernel': s.kernel,
209			'idle': s.idle,
210			'iowait': s.iowait,
211			'swap': s.swap,
212			'nice': s.nice,
213			'time_taken': s.time_taken,
214			}
215			)
216	tdb	1.1
217			def py_get_memory_stats():
218			cdef mem_stat_t *s
219			s = get_memory_stats()
220	tdb	1.3	if s == NULL:
221			raise StatgrabException, 'get_memory_stats() returned NULL'
222	tdb	1.2	return Result(
223			{'total': s.total,
224			'used': s.used,
225			'free': s.free,
226			'cache': s.cache,
227			}
228			)
229	tdb	1.1
230			def py_get_load_stats():
231			cdef load_stat_t *s
232			s = get_load_stats()
233	tdb	1.3	if s == NULL:
234			raise StatgrabException, 'get_load_stats() returned NULL'
235	tdb	1.2	return Result(
236			{'min1': s.min1,
237			'min5': s.min5,
238			'min15': s.min15,
239			}
240			)
241	tdb	1.1
242			def py_get_user_stats():
243			cdef user_stat_t *s
244			s = get_user_stats()
245	tdb	1.3	if s == NULL:
246			raise StatgrabException, 'get_user_stats() returned NULL'
247	tdb	1.2	return Result(
248			{'name_list': s.name_list,
249			'num_entries': s.num_entries,
250			}
251			)
252	tdb	1.1
253			def py_get_swap_stats():
254			cdef swap_stat_t *s
255			s = get_swap_stats()
256	tdb	1.3	if s == NULL:
257			raise StatgrabException, 'get_swap_stats() returned NULL'
258	tdb	1.2	return Result(
259			{'total': s.total,
260			'used': s.used,
261			'free': s.free,
262			}
263			)
264	tdb	1.1
265			def py_get_general_stats():
266			cdef general_stat_t *s
267			s = get_general_stats()
268	tdb	1.3	if s == NULL:
269			raise StatgrabException, 'get_general_stats() returned NULL'
270	tdb	1.2	return Result(
271			{'os_name': s.os_name,
272			'os_release': s.os_release,
273			'os_version': s.os_version,
274			'platform': s.platform,
275			'hostname': s.hostname,
276			'uptime': s.uptime,
277			}
278			)
279	tdb	1.1
280			def py_get_disk_stats():
281			cdef disk_stat_t *s
282			cdef int entries
283			s = get_disk_stats(&entries)
284	tdb	1.3	if s == NULL:
285			raise StatgrabException, 'get_disk_stats() returned NULL'
286	tdb	1.6	list = []
287	tdb	1.1	for i from 0 <= i < entries:
288	tdb	1.2	list.append(Result(
289			{'device_name': s.device_name,
290			'fs_type': s.fs_type,
291			'mnt_point': s.mnt_point,
292			'size': s.size,
293			'used': s.used,
294			'avail': s.avail,
295			'total_inodes': s.total_inodes,
296			'used_inodes': s.used_inodes,
297			'free_inodes': s.free_inodes,
298			}
299			))
300	tdb	1.1	s = s + 1
301			return list
302
303			def py_get_diskio_stats():
304			cdef diskio_stat_t *s
305			cdef int entries
306			s = get_diskio_stats(&entries)
307	tdb	1.3	if s == NULL:
308			raise StatgrabException, 'get_diskio_stats() returned NULL'
309	tdb	1.6	list = []
310	tdb	1.1	for i from 0 <= i < entries:
311	tdb	1.2	list.append(Result(
312			{'disk_name': s.disk_name,
313			'read_bytes': s.read_bytes,
314			'write_bytes': s.write_bytes,
315			'systime': s.systime,
316			}
317			))
318	tdb	1.1	s = s + 1
319			return list
320
321			def py_get_diskio_stats_diff():
322			cdef diskio_stat_t *s
323			cdef int entries
324			s = get_diskio_stats_diff(&entries)
325	tdb	1.3	if s == NULL:
326			raise StatgrabException, 'get_diskio_stats_diff() returned NULL'
327	tdb	1.6	list = []
328	tdb	1.1	for i from 0 <= i < entries:
329	tdb	1.2	list.append(Result(
330			{'disk_name': s.disk_name,
331			'read_bytes': s.read_bytes,
332			'write_bytes': s.write_bytes,
333			'systime': s.systime,
334			}
335			))
336	tdb	1.1	s = s + 1
337			return list
338
339			def py_get_process_stats():
340			cdef process_stat_t *s
341			s = get_process_stats()
342	tdb	1.3	if s == NULL:
343			raise StatgrabException, 'get_process_stats() returned NULL'
344	tdb	1.2	return Result(
345			{'total': s.total,
346			'running': s.running,
347			'sleeping': s.sleeping,
348			'stopped': s.stopped,
349			'zombie': s.zombie,
350			}
351			)
352	tdb	1.1
353			def py_get_network_stats():
354			cdef network_stat_t *s
355			cdef int entries
356			s = get_network_stats(&entries)
357	tdb	1.3	if s == NULL:
358			raise StatgrabException, 'get_network_stats() returned NULL'
359	tdb	1.6	list = []
360	tdb	1.1	for i from 0 <= i < entries:
361	tdb	1.2	list.append(Result(
362			{'interface_name': s.interface_name,
363			'tx': s.tx,
364			'rx': s.rx,
365	tdb	1.9	'ipackets': s.ipackets,
366			'opackets': s.opackets,
367			'ierrors': s.ierrors,
368			'oerrors': s.oerrors,
369			'collisions': s.collisions,
370	tdb	1.2	'systime': s.systime,
371			}
372			))
373	tdb	1.1	s = s + 1
374			return list
375
376			def py_get_network_stats_diff():
377			cdef network_stat_t *s
378			cdef int entries
379			s = get_network_stats_diff(&entries)
380	tdb	1.3	if s == NULL:
381			raise StatgrabException, 'get_network_stats_diff() returned NULL'
382	tdb	1.6	list = []
383	tdb	1.1	for i from 0 <= i < entries:
384	tdb	1.2	list.append(Result(
385			{'interface_name': s.interface_name,
386			'tx': s.tx,
387			'rx': s.rx,
388	tdb	1.9	'ipackets': s.ipackets,
389			'opackets': s.opackets,
390			'ierrors': s.ierrors,
391			'oerrors': s.oerrors,
392			'collisions': s.collisions,
393	tdb	1.2	'systime': s.systime,
394	tdb	1.5	}
395			))
396			s = s + 1
397			return list
398
399			def py_get_network_iface_stats():
400			cdef network_iface_stat_t *s
401			cdef int entries
402			s = get_network_iface_stats(&entries)
403			if s == NULL:
404			raise StatgrabException, 'get_network_iface_stats() returned NULL'
405	tdb	1.6	list = []
406	tdb	1.5	for i from 0 <= i < entries:
407			list.append(Result(
408			{'interface_name': s.interface_name,
409			'speed': s.speed,
410			'dup': s.dup,
411	tdb	1.8	'up' : s.up,
412	tdb	1.2	}
413			))
414	tdb	1.1	s = s + 1
415			return list
416
417			def py_get_page_stats():
418			cdef page_stat_t *s
419			s = get_page_stats()
420	tdb	1.3	if s == NULL:
421			raise StatgrabException, 'get_page_stats() returned NULL'
422	tdb	1.2	return Result(
423			{'pages_pagein': s.pages_pagein,
424			'pages_pageout': s.pages_pageout,
425			}
426			)
427	tdb	1.1
428			def py_get_page_stats_diff():
429			cdef page_stat_t *s
430			s = get_page_stats_diff()
431	tdb	1.3	if s == NULL:
432			raise StatgrabException, 'get_page_stats_diff() returned NULL'
433	tdb	1.2	return Result(
434			{'pages_pagein': s.pages_pagein,
435			'pages_pageout': s.pages_pageout,
436			}
437			)
438	tdb	1.1
439			def py_statgrab_init():
440			return statgrab_init()
441
442			def py_statgrab_drop_privileges():
443			return statgrab_drop_privileges()