projects/pystatgrab/_statgrab.pyx

#
# i-scream pystatgrab
# 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.12 2004/05/30 15:21:19 tdb Exp $
#

ctypedef long time_t

cdef extern from "statgrab.h":
    cdef extern int sg_init()
    cdef extern int sg_drop_privileges()

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

    cdef extern sg_host_info *sg_get_host_info()

    ctypedef struct sg_cpu_stats:
        long long user
        long long kernel
        long long idle
        long long iowait
        long long swap
        long long nice
        long long total
        time_t systime

    cdef extern sg_cpu_stats *sg_get_cpu_stats()
    cdef extern sg_cpu_stats *sg_get_cpu_stats_diff()

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

    cdef extern sg_cpu_percents *sg_get_cpu_percents()

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

    cdef extern sg_mem_stats *sg_get_mem_stats()

    ctypedef struct sg_load_stats:
        double min1
        double min5
        double min15

    cdef extern sg_load_stats *sg_get_load_stats()

    ctypedef struct sg_user_stats:
        char *name_list
        int num_entries

    cdef extern sg_user_stats *sg_get_user_stats()

    ctypedef struct sg_swap_stats:
        long long total
        long long used
        long long free

    cdef extern sg_swap_stats *sg_get_swap_stats()

    ctypedef struct sg_fs_stats:
        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

    cdef extern sg_fs_stats *sg_get_fs_stats(int *entries)

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

    cdef extern sg_disk_io_stats *sg_get_disk_io_stats(int *entries)
    cdef extern sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries)

    ctypedef struct sg_network_io_stats:
        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

    cdef extern sg_network_io_stats *sg_get_network_io_stats(int *entries)
    cdef extern sg_network_io_stats *sg_get_network_io_stats_diff(int *entries)

    ctypedef enum sg_iface_duplex:
        SG_IFACE_DUPLEX_FULL
        SG_IFACE_DUPLEX_HALF
        SG_IFACE_DUPLEX_UNKNOWN

    ctypedef struct sg_network_iface_stats:
        char *interface_name
        int speed
        sg_iface_duplex dup
        int up

    cdef extern sg_network_iface_stats *sg_get_network_iface_stats(int *entries)

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

    cdef extern sg_page_stats *sg_get_page_stats()
    cdef extern sg_page_stats *sg_get_page_stats_diff()

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

    cdef extern sg_process_count *sg_get_process_count()


py_SG_IFACE_DUPLEX_FULL = SG_IFACE_DUPLEX_FULL
py_SG_IFACE_DUPLEX_HALF = SG_IFACE_DUPLEX_HALF
py_SG_IFACE_DUPLEX_UNKNOWN = SG_IFACE_DUPLEX_UNKNOWN


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_sg_init():
    if sg_init() == 0:
        return True
    else:
        return False

def py_sg_drop_privileges():
    if sg_drop_privileges() == 0:
        return True
    else:
        return False

def py_sg_get_host_info():
    cdef sg_host_info *s
    s = sg_get_host_info()
    if s == NULL:
        raise StatgrabException, 'sg_get_host_info() 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_sg_get_cpu_stats():
    cdef sg_cpu_stats *s
    s = sg_get_cpu_stats()
    if s == NULL:
        raise StatgrabException, 'sg_get_cpu_stats() 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_sg_get_cpu_stats_diff():
    cdef sg_cpu_stats *s
    s = sg_get_cpu_stats_diff()
    if s == NULL:
        raise StatgrabException, 'sg_get_cpu_stats_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_sg_get_cpu_percents():
    cdef sg_cpu_percents *s
    s = sg_get_cpu_percents()
    if s == NULL:
        raise StatgrabException, 'sg_get_cpu_percents() 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_sg_get_mem_stats():
    cdef sg_mem_stats *s
    s = sg_get_mem_stats()
    if s == NULL:
        raise StatgrabException, 'sg_get_mem_stats() returned NULL'
    return Result(
        {'total': s.total,
         'used': s.used,
         'free': s.free,
         'cache': s.cache,
        }
    )

def py_sg_get_load_stats():
    cdef sg_load_stats *s
    s = sg_get_load_stats()
    if s == NULL:
        raise StatgrabException, 'sg_get_load_stats() returned NULL'
    return Result(
        {'min1': s.min1,
         'min5': s.min5,
         'min15': s.min15,
        }
    )

def py_sg_get_user_stats():
    cdef sg_user_stats *s
    s = sg_get_user_stats()
    if s == NULL:
        raise StatgrabException, 'sg_get_user_stats() returned NULL'
    return Result(
        {'name_list': s.name_list,
         'num_entries': s.num_entries,
        }
    )

def py_sg_get_swap_stats():
    cdef sg_swap_stats *s
    s = sg_get_swap_stats()
    if s == NULL:
        raise StatgrabException, 'sg_get_swap_stats() returned NULL'
    return Result(
        {'total': s.total,
         'used': s.used,
         'free': s.free,
        }
    )

def py_sg_get_fs_stats():
    cdef sg_fs_stats *s
    cdef int entries
    s = sg_get_fs_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_get_fs_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_sg_get_disk_io_stats():
    cdef sg_disk_io_stats *s
    cdef int entries
    s = sg_get_disk_io_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_get_disk_io_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_sg_get_disk_io_stats_diff():
    cdef sg_disk_io_stats *s
    cdef int entries
    s = sg_get_disk_io_stats_diff(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_get_disk_io_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_sg_get_network_io_stats():
    cdef sg_network_io_stats *s
    cdef int entries
    s = sg_get_network_io_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_get_network_io_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_sg_get_network_io_stats_diff():
    cdef sg_network_io_stats *s
    cdef int entries
    s = sg_get_network_io_stats_diff(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_get_network_io_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_sg_get_network_iface_stats():
    cdef sg_network_iface_stats *s
    cdef int entries
    s = sg_get_network_iface_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_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_sg_get_page_stats():
    cdef sg_page_stats *s
    s = sg_get_page_stats()
    if s == NULL:
        raise StatgrabException, 'sg_get_page_stats() returned NULL'
    return Result(
        {'pages_pagein': s.pages_pagein,
         'pages_pageout': s.pages_pageout,
        }
    )

def py_sg_get_page_stats_diff():
    cdef sg_page_stats *s
    s = sg_get_page_stats_diff()
    if s == NULL:
        raise StatgrabException, 'sg_get_page_stats_diff() returned NULL'
    return Result(
        {'pages_pagein': s.pages_pagein,
         'pages_pageout': s.pages_pageout,
        }
    )

def py_sg_get_process_count():
    cdef sg_process_count *s
    s = sg_get_process_count()
    if s == NULL:
        raise StatgrabException, 'sg_get_process_count() returned NULL'
    return Result(
        {'total': s.total,
         'running': s.running,
         'sleeping': s.sleeping,
         'stopped': s.stopped,
         'zombie': s.zombie,
        }
    )
Revision:	1.13
Committed:	Sun May 30 15:32:28 2004 UTC (21 years, 5 months ago) by tdb
Branch:	MAIN
Changes since 1.12:	+84 -71 lines
Log Message:	Stage 2: Reorder functions and structures to match statgrab.h order.
#	User	Rev	Content
1	tdb	1.3	#
2	tdb	1.11	# i-scream pystatgrab
3	tdb	1.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.13	# $Id: _statgrab.pyx,v 1.12 2004/05/30 15:21:19 tdb Exp $
21	tdb	1.3	#
22	tdb	1.1
23			ctypedef long time_t
24
25			cdef extern from "statgrab.h":
26	tdb	1.13	cdef extern int sg_init()
27			cdef extern int sg_drop_privileges()
28
29			ctypedef struct sg_host_info:
30			char *os_name
31			char *os_release
32			char *os_version
33			char *platform
34			char *hostname
35			time_t uptime
36
37			cdef extern sg_host_info *sg_get_host_info()
38
39	tdb	1.12	ctypedef struct sg_cpu_stats:
40	tdb	1.1	long long user
41			long long kernel
42			long long idle
43			long long iowait
44			long long swap
45			long long nice
46			long long total
47			time_t systime
48
49	tdb	1.13	cdef extern sg_cpu_stats *sg_get_cpu_stats()
50			cdef extern sg_cpu_stats *sg_get_cpu_stats_diff()
51
52	tdb	1.12	ctypedef struct sg_cpu_percents:
53	tdb	1.1	float user
54			float kernel
55			float idle
56			float iowait
57			float swap
58			float nice
59			time_t time_taken
60
61	tdb	1.13	cdef extern sg_cpu_percents *sg_get_cpu_percents()
62
63	tdb	1.12	ctypedef struct sg_mem_stats:
64	tdb	1.1	long long total
65			long long free
66			long long used
67			long long cache
68
69	tdb	1.13	cdef extern sg_mem_stats *sg_get_mem_stats()
70
71	tdb	1.12	ctypedef struct sg_load_stats:
72	tdb	1.1	double min1
73			double min5
74			double min15
75
76	tdb	1.13	cdef extern sg_load_stats *sg_get_load_stats()
77
78	tdb	1.12	ctypedef struct sg_user_stats:
79	tdb	1.1	char *name_list
80			int num_entries
81
82	tdb	1.13	cdef extern sg_user_stats *sg_get_user_stats()
83
84	tdb	1.12	ctypedef struct sg_swap_stats:
85	tdb	1.1	long long total
86			long long used
87			long long free
88
89	tdb	1.13	cdef extern sg_swap_stats *sg_get_swap_stats()
90	tdb	1.1
91	tdb	1.12	ctypedef struct sg_fs_stats:
92	tdb	1.1	char *device_name
93			char *fs_type
94			char *mnt_point
95			long long size
96			long long used
97			long long avail
98			long long total_inodes
99			long long used_inodes
100			long long free_inodes
101
102	tdb	1.13	cdef extern sg_fs_stats sg_get_fs_stats(int entries)
103
104	tdb	1.12	ctypedef struct sg_disk_io_stats:
105	tdb	1.1	char *disk_name
106			long long read_bytes
107			long long write_bytes
108			time_t systime
109
110	tdb	1.13	cdef extern sg_disk_io_stats sg_get_disk_io_stats(int entries)
111			cdef extern sg_disk_io_stats sg_get_disk_io_stats_diff(int entries)
112	tdb	1.1
113	tdb	1.12	ctypedef struct sg_network_io_stats:
114	tdb	1.1	char *interface_name
115			long long tx
116			long long rx
117	tdb	1.9	long long ipackets
118			long long opackets
119			long long ierrors
120			long long oerrors
121			long long collisions
122	tdb	1.1	time_t systime
123
124	tdb	1.13	cdef extern sg_network_io_stats sg_get_network_io_stats(int entries)
125			cdef extern sg_network_io_stats sg_get_network_io_stats_diff(int entries)
126
127	tdb	1.12	ctypedef enum sg_iface_duplex:
128			SG_IFACE_DUPLEX_FULL
129			SG_IFACE_DUPLEX_HALF
130			SG_IFACE_DUPLEX_UNKNOWN
131	tdb	1.5
132	tdb	1.12	ctypedef struct sg_network_iface_stats:
133	tdb	1.5	char *interface_name
134			int speed
135	tdb	1.12	sg_iface_duplex dup
136	tdb	1.8	int up
137	tdb	1.5
138	tdb	1.13	cdef extern sg_network_iface_stats sg_get_network_iface_stats(int entries)
139
140	tdb	1.12	ctypedef struct sg_page_stats:
141	tdb	1.1	long long pages_pagein
142			long long pages_pageout
143			time_t systime
144
145	tdb	1.12	cdef extern sg_page_stats *sg_get_page_stats()
146			cdef extern sg_page_stats *sg_get_page_stats_diff()
147	tdb	1.13
148			ctypedef struct sg_process_count:
149			int total
150			int running
151			int sleeping
152			int stopped
153			int zombie
154
155			cdef extern sg_process_count *sg_get_process_count()
156	tdb	1.12
157
158			py_SG_IFACE_DUPLEX_FULL = SG_IFACE_DUPLEX_FULL
159			py_SG_IFACE_DUPLEX_HALF = SG_IFACE_DUPLEX_HALF
160			py_SG_IFACE_DUPLEX_UNKNOWN = SG_IFACE_DUPLEX_UNKNOWN
161	tdb	1.1
162
163	tdb	1.2	class Result:
164			def __init__(self, attrs):
165			self.attrs = attrs
166			for attr in attrs:
167			setattr(self, attr, attrs[attr])
168			def __getitem__(self, item):
169			return getattr(self, item)
170			def __repr__(self):
171			return str(self.attrs)
172
173	tdb	1.4	class StatgrabException(Exception):
174	tdb	1.3	def __init__(self, value):
175			self.value = value
176			def __str__(self):
177			return repr(self.value)
178
179	tdb	1.2
180	tdb	1.13	def py_sg_init():
181			if sg_init() == 0:
182			return True
183			else:
184			return False
185
186			def py_sg_drop_privileges():
187			if sg_drop_privileges() == 0:
188			return True
189			else:
190			return False
191
192			def py_sg_get_host_info():
193			cdef sg_host_info *s
194			s = sg_get_host_info()
195			if s == NULL:
196			raise StatgrabException, 'sg_get_host_info() returned NULL'
197			return Result(
198			{'os_name': s.os_name,
199			'os_release': s.os_release,
200			'os_version': s.os_version,
201			'platform': s.platform,
202			'hostname': s.hostname,
203			'uptime': s.uptime,
204			}
205			)
206
207	tdb	1.12	def py_sg_get_cpu_stats():
208			cdef sg_cpu_stats *s
209			s = sg_get_cpu_stats()
210	tdb	1.3	if s == NULL:
211	tdb	1.12	raise StatgrabException, 'sg_get_cpu_stats() returned NULL'
212	tdb	1.2	return Result(
213			{'user': s.user,
214			'kernel': s.kernel,
215			'idle': s.idle,
216			'iowait': s.iowait,
217			'swap': s.swap,
218			'nice': s.nice,
219			'total': s.total,
220			'systime': s.systime,
221			}
222			)
223	tdb	1.1
224	tdb	1.12	def py_sg_get_cpu_stats_diff():
225			cdef sg_cpu_stats *s
226			s = sg_get_cpu_stats_diff()
227	tdb	1.3	if s == NULL:
228	tdb	1.12	raise StatgrabException, 'sg_get_cpu_stats_diff() returned NULL'
229	tdb	1.2	return Result(
230			{'user': s.user,
231			'kernel': s.kernel,
232			'idle': s.idle,
233			'iowait': s.iowait,
234			'swap': s.swap,
235			'nice': s.nice,
236			'total': s.total,
237			'systime': s.systime,
238			}
239			)
240	tdb	1.1
241	tdb	1.12	def py_sg_get_cpu_percents():
242			cdef sg_cpu_percents *s
243			s = sg_get_cpu_percents()
244	tdb	1.3	if s == NULL:
245	tdb	1.12	raise StatgrabException, 'sg_get_cpu_percents() returned NULL'
246	tdb	1.2	return Result(
247			{'user': s.user,
248			'kernel': s.kernel,
249			'idle': s.idle,
250			'iowait': s.iowait,
251			'swap': s.swap,
252			'nice': s.nice,
253			'time_taken': s.time_taken,
254			}
255			)
256	tdb	1.1
257	tdb	1.12	def py_sg_get_mem_stats():
258			cdef sg_mem_stats *s
259			s = sg_get_mem_stats()
260	tdb	1.3	if s == NULL:
261	tdb	1.12	raise StatgrabException, 'sg_get_mem_stats() returned NULL'
262	tdb	1.2	return Result(
263			{'total': s.total,
264			'used': s.used,
265			'free': s.free,
266			'cache': s.cache,
267			}
268			)
269	tdb	1.1
270	tdb	1.12	def py_sg_get_load_stats():
271			cdef sg_load_stats *s
272			s = sg_get_load_stats()
273	tdb	1.3	if s == NULL:
274	tdb	1.12	raise StatgrabException, 'sg_get_load_stats() returned NULL'
275	tdb	1.2	return Result(
276			{'min1': s.min1,
277			'min5': s.min5,
278			'min15': s.min15,
279			}
280			)
281	tdb	1.1
282	tdb	1.12	def py_sg_get_user_stats():
283			cdef sg_user_stats *s
284			s = sg_get_user_stats()
285	tdb	1.3	if s == NULL:
286	tdb	1.12	raise StatgrabException, 'sg_get_user_stats() returned NULL'
287	tdb	1.2	return Result(
288			{'name_list': s.name_list,
289			'num_entries': s.num_entries,
290			}
291			)
292	tdb	1.1
293	tdb	1.12	def py_sg_get_swap_stats():
294			cdef sg_swap_stats *s
295			s = sg_get_swap_stats()
296	tdb	1.3	if s == NULL:
297	tdb	1.12	raise StatgrabException, 'sg_get_swap_stats() returned NULL'
298	tdb	1.2	return Result(
299			{'total': s.total,
300			'used': s.used,
301			'free': s.free,
302			}
303			)
304	tdb	1.1
305	tdb	1.12	def py_sg_get_fs_stats():
306			cdef sg_fs_stats *s
307	tdb	1.1	cdef int entries
308	tdb	1.12	s = sg_get_fs_stats(&entries)
309	tdb	1.3	if s == NULL:
310	tdb	1.12	raise StatgrabException, 'sg_get_fs_stats() returned NULL'
311	tdb	1.6	list = []
312	tdb	1.1	for i from 0 <= i < entries:
313	tdb	1.2	list.append(Result(
314			{'device_name': s.device_name,
315			'fs_type': s.fs_type,
316			'mnt_point': s.mnt_point,
317			'size': s.size,
318			'used': s.used,
319			'avail': s.avail,
320			'total_inodes': s.total_inodes,
321			'used_inodes': s.used_inodes,
322			'free_inodes': s.free_inodes,
323			}
324			))
325	tdb	1.1	s = s + 1
326			return list
327
328	tdb	1.12	def py_sg_get_disk_io_stats():
329			cdef sg_disk_io_stats *s
330	tdb	1.1	cdef int entries
331	tdb	1.12	s = sg_get_disk_io_stats(&entries)
332	tdb	1.3	if s == NULL:
333	tdb	1.12	raise StatgrabException, 'sg_get_disk_io_stats() returned NULL'
334	tdb	1.6	list = []
335	tdb	1.1	for i from 0 <= i < entries:
336	tdb	1.2	list.append(Result(
337			{'disk_name': s.disk_name,
338			'read_bytes': s.read_bytes,
339			'write_bytes': s.write_bytes,
340			'systime': s.systime,
341			}
342			))
343	tdb	1.1	s = s + 1
344			return list
345
346	tdb	1.12	def py_sg_get_disk_io_stats_diff():
347			cdef sg_disk_io_stats *s
348	tdb	1.1	cdef int entries
349	tdb	1.12	s = sg_get_disk_io_stats_diff(&entries)
350	tdb	1.3	if s == NULL:
351	tdb	1.12	raise StatgrabException, 'sg_get_disk_io_stats_diff() returned NULL'
352	tdb	1.6	list = []
353	tdb	1.1	for i from 0 <= i < entries:
354	tdb	1.2	list.append(Result(
355			{'disk_name': s.disk_name,
356			'read_bytes': s.read_bytes,
357			'write_bytes': s.write_bytes,
358			'systime': s.systime,
359			}
360			))
361	tdb	1.1	s = s + 1
362			return list
363
364	tdb	1.12	def py_sg_get_network_io_stats():
365			cdef sg_network_io_stats *s
366	tdb	1.1	cdef int entries
367	tdb	1.12	s = sg_get_network_io_stats(&entries)
368	tdb	1.3	if s == NULL:
369	tdb	1.12	raise StatgrabException, 'sg_get_network_io_stats() returned NULL'
370	tdb	1.6	list = []
371	tdb	1.1	for i from 0 <= i < entries:
372	tdb	1.2	list.append(Result(
373			{'interface_name': s.interface_name,
374			'tx': s.tx,
375			'rx': s.rx,
376	tdb	1.9	'ipackets': s.ipackets,
377			'opackets': s.opackets,
378			'ierrors': s.ierrors,
379			'oerrors': s.oerrors,
380			'collisions': s.collisions,
381	tdb	1.2	'systime': s.systime,
382			}
383			))
384	tdb	1.1	s = s + 1
385			return list
386
387	tdb	1.12	def py_sg_get_network_io_stats_diff():
388			cdef sg_network_io_stats *s
389	tdb	1.1	cdef int entries
390	tdb	1.12	s = sg_get_network_io_stats_diff(&entries)
391	tdb	1.3	if s == NULL:
392	tdb	1.12	raise StatgrabException, 'sg_get_network_io_stats_diff() returned NULL'
393	tdb	1.6	list = []
394	tdb	1.1	for i from 0 <= i < entries:
395	tdb	1.2	list.append(Result(
396			{'interface_name': s.interface_name,
397			'tx': s.tx,
398			'rx': s.rx,
399	tdb	1.9	'ipackets': s.ipackets,
400			'opackets': s.opackets,
401			'ierrors': s.ierrors,
402			'oerrors': s.oerrors,
403			'collisions': s.collisions,
404	tdb	1.2	'systime': s.systime,
405	tdb	1.5	}
406			))
407			s = s + 1
408			return list
409
410	tdb	1.12	def py_sg_get_network_iface_stats():
411			cdef sg_network_iface_stats *s
412	tdb	1.5	cdef int entries
413	tdb	1.12	s = sg_get_network_iface_stats(&entries)
414	tdb	1.5	if s == NULL:
415	tdb	1.12	raise StatgrabException, 'sg_get_network_iface_stats() returned NULL'
416	tdb	1.6	list = []
417	tdb	1.5	for i from 0 <= i < entries:
418			list.append(Result(
419			{'interface_name': s.interface_name,
420			'speed': s.speed,
421			'dup': s.dup,
422	tdb	1.8	'up' : s.up,
423	tdb	1.2	}
424			))
425	tdb	1.1	s = s + 1
426			return list
427
428	tdb	1.12	def py_sg_get_page_stats():
429			cdef sg_page_stats *s
430			s = sg_get_page_stats()
431	tdb	1.3	if s == NULL:
432	tdb	1.12	raise StatgrabException, 'sg_get_page_stats() 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	tdb	1.12	def py_sg_get_page_stats_diff():
440			cdef sg_page_stats *s
441			s = sg_get_page_stats_diff()
442	tdb	1.3	if s == NULL:
443	tdb	1.12	raise StatgrabException, 'sg_get_page_stats_diff() returned NULL'
444	tdb	1.2	return Result(
445			{'pages_pagein': s.pages_pagein,
446			'pages_pageout': s.pages_pageout,
447			}
448			)
449	tdb	1.1
450	tdb	1.13	def py_sg_get_process_count():
451			cdef sg_process_count *s
452			s = sg_get_process_count()
453			if s == NULL:
454			raise StatgrabException, 'sg_get_process_count() returned NULL'
455			return Result(
456			{'total': s.total,
457			'running': s.running,
458			'sleeping': s.sleeping,
459			'stopped': s.stopped,
460			'zombie': s.zombie,
461			}
462			)