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.
#	Content
1	#
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	# $Id: statgrab.pyx,v 1.9 2004/03/06 22:11:22 tdb Exp $
21	#
22
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	long long ipackets
102	long long opackets
103	long long ierrors
104	long long oerrors
105	long long collisions
106	time_t systime
107
108	ctypedef enum statgrab_duplex:
109	FULL_DUPLEX
110	HALF_DUPLEX
111	UNKNOWN_DUPLEX
112
113	ctypedef struct network_iface_stat_t:
114	char *interface_name
115	int speed
116	statgrab_duplex dup
117	int up
118
119	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	cdef extern network_iface_stat_t get_network_iface_stats(int entries)
139	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
144
145	py_FULL_DUPLEX = FULL_DUPLEX
146	py_HALF_DUPLEX = HALF_DUPLEX
147	py_UNKNOWN_DUPLEX = UNKNOWN_DUPLEX
148
149
150	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	class StatgrabException(Exception):
161	def __init__(self, value):
162	self.value = value
163	def __str__(self):
164	return repr(self.value)
165
166
167	def py_get_cpu_totals():
168	cdef cpu_states_t *s
169	s = get_cpu_totals()
170	if s == NULL:
171	raise StatgrabException, 'get_cpu_totals() returned NULL'
172	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
184	def py_get_cpu_diff():
185	cdef cpu_states_t *s
186	s = get_cpu_diff()
187	if s == NULL:
188	raise StatgrabException, 'get_cpu_diff() returned NULL'
189	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
201	def py_cpu_percent_usage():
202	cdef cpu_percent_t *s
203	s = cpu_percent_usage()
204	if s == NULL:
205	raise StatgrabException, 'cpu_percent_usage() returned NULL'
206	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
217	def py_get_memory_stats():
218	cdef mem_stat_t *s
219	s = get_memory_stats()
220	if s == NULL:
221	raise StatgrabException, 'get_memory_stats() returned NULL'
222	return Result(
223	{'total': s.total,
224	'used': s.used,
225	'free': s.free,
226	'cache': s.cache,
227	}
228	)
229
230	def py_get_load_stats():
231	cdef load_stat_t *s
232	s = get_load_stats()
233	if s == NULL:
234	raise StatgrabException, 'get_load_stats() returned NULL'
235	return Result(
236	{'min1': s.min1,
237	'min5': s.min5,
238	'min15': s.min15,
239	}
240	)
241
242	def py_get_user_stats():
243	cdef user_stat_t *s
244	s = get_user_stats()
245	if s == NULL:
246	raise StatgrabException, 'get_user_stats() returned NULL'
247	return Result(
248	{'name_list': s.name_list,
249	'num_entries': s.num_entries,
250	}
251	)
252
253	def py_get_swap_stats():
254	cdef swap_stat_t *s
255	s = get_swap_stats()
256	if s == NULL:
257	raise StatgrabException, 'get_swap_stats() returned NULL'
258	return Result(
259	{'total': s.total,
260	'used': s.used,
261	'free': s.free,
262	}
263	)
264
265	def py_get_general_stats():
266	cdef general_stat_t *s
267	s = get_general_stats()
268	if s == NULL:
269	raise StatgrabException, 'get_general_stats() returned NULL'
270	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
280	def py_get_disk_stats():
281	cdef disk_stat_t *s
282	cdef int entries
283	s = get_disk_stats(&entries)
284	if s == NULL:
285	raise StatgrabException, 'get_disk_stats() returned NULL'
286	list = []
287	for i from 0 <= i < entries:
288	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	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	if s == NULL:
308	raise StatgrabException, 'get_diskio_stats() returned NULL'
309	list = []
310	for i from 0 <= i < entries:
311	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	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	if s == NULL:
326	raise StatgrabException, 'get_diskio_stats_diff() returned NULL'
327	list = []
328	for i from 0 <= i < entries:
329	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	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	if s == NULL:
343	raise StatgrabException, 'get_process_stats() returned NULL'
344	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
353	def py_get_network_stats():
354	cdef network_stat_t *s
355	cdef int entries
356	s = get_network_stats(&entries)
357	if s == NULL:
358	raise StatgrabException, 'get_network_stats() returned NULL'
359	list = []
360	for i from 0 <= i < entries:
361	list.append(Result(
362	{'interface_name': s.interface_name,
363	'tx': s.tx,
364	'rx': s.rx,
365	'ipackets': s.ipackets,
366	'opackets': s.opackets,
367	'ierrors': s.ierrors,
368	'oerrors': s.oerrors,
369	'collisions': s.collisions,
370	'systime': s.systime,
371	}
372	))
373	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	if s == NULL:
381	raise StatgrabException, 'get_network_stats_diff() returned NULL'
382	list = []
383	for i from 0 <= i < entries:
384	list.append(Result(
385	{'interface_name': s.interface_name,
386	'tx': s.tx,
387	'rx': s.rx,
388	'ipackets': s.ipackets,
389	'opackets': s.opackets,
390	'ierrors': s.ierrors,
391	'oerrors': s.oerrors,
392	'collisions': s.collisions,
393	'systime': s.systime,
394	}
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	list = []
406	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	'up' : s.up,
412	}
413	))
414	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	if s == NULL:
421	raise StatgrabException, 'get_page_stats() returned NULL'
422	return Result(
423	{'pages_pagein': s.pages_pagein,
424	'pages_pageout': s.pages_pageout,
425	}
426	)
427
428	def py_get_page_stats_diff():
429	cdef page_stat_t *s
430	s = get_page_stats_diff()
431	if s == NULL:
432	raise StatgrabException, 'get_page_stats_diff() returned NULL'
433	return Result(
434	{'pages_pagein': s.pages_pagein,
435	'pages_pageout': s.pages_pageout,
436	}
437	)
438
439	def py_statgrab_init():
440	return statgrab_init()
441
442	def py_statgrab_drop_privileges():
443	return statgrab_drop_privileges()