ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/pystatgrab/_statgrab.pyx

Comparing projects/pystatgrab/_statgrab.pyx (file contents):
Revision 1.12 by tdb, Sun May 30 15:21:19 2004 UTC vs.
Revision 1.21 by tdb, Mon Jun 16 21:06:49 2008 UTC

#	Line 1 | Line 1
1		#
2		# i-scream pystatgrab
3	<	# http://www.i-scream.org
3	>	# http://www.i-scream.org/pystatgrab/
4		# Copyright (C) 2000-2004 i-scream
5		#
6		# This program is free software; you can redistribute it and/or
#	Line 21 | Line 21
21		#
22
23		ctypedef long time_t
24	+	ctypedef int pid_t
25	+	ctypedef int uid_t
26	+	ctypedef int gid_t
27
28		cdef extern from "statgrab.h":
29	+	cdef extern int sg_init()
30	+	cdef extern int sg_shutdown()
31	+	cdef extern int sg_snapshot()
32	+	cdef extern int sg_drop_privileges()
33	+
34	+	ctypedef enum sg_error:
35	+	SG_ERROR_NONE = 0
36	+	SG_ERROR_ASPRINTF
37	+	SG_ERROR_DEVSTAT_GETDEVS
38	+	SG_ERROR_DEVSTAT_SELECTDEVS
39	+	SG_ERROR_ENOENT
40	+	SG_ERROR_GETIFADDRS
41	+	SG_ERROR_GETMNTINFO
42	+	SG_ERROR_GETPAGESIZE
43	+	SG_ERROR_KSTAT_DATA_LOOKUP
44	+	SG_ERROR_KSTAT_LOOKUP
45	+	SG_ERROR_KSTAT_OPEN
46	+	SG_ERROR_KSTAT_READ
47	+	SG_ERROR_KVM_GETSWAPINFO
48	+	SG_ERROR_KVM_OPENFILES
49	+	SG_ERROR_MALLOC
50	+	SG_ERROR_OPEN
51	+	SG_ERROR_OPENDIR
52	+	SG_ERROR_PARSE
53	+	SG_ERROR_SETEGID
54	+	SG_ERROR_SETEUID
55	+	SG_ERROR_SETMNTENT
56	+	SG_ERROR_SOCKET
57	+	SG_ERROR_SWAPCTL
58	+	SG_ERROR_SYSCONF
59	+	SG_ERROR_SYSCTL
60	+	SG_ERROR_SYSCTLBYNAME
61	+	SG_ERROR_SYSCTLNAMETOMIB
62	+	SG_ERROR_UNAME
63	+	SG_ERROR_UNSUPPORTED
64	+	SG_ERROR_XSW_VER_MISMATCH
65	+
66	+	cdef extern void sg_set_error(sg_error code, char *arg)
67	+	cdef extern void sg_set_error_with_errno(sg_error code, char *arg)
68	+	cdef extern sg_error sg_get_error()
69	+	cdef extern char *sg_get_error_arg()
70	+	cdef extern int sg_get_error_errno()
71	+	cdef extern char *sg_str_error(sg_error code)
72	+
73	+	ctypedef struct sg_host_info:
74	+	char *os_name
75	+	char *os_release
76	+	char *os_version
77	+	char *platform
78	+	char *hostname
79	+	time_t uptime
80	+
81	+	cdef extern sg_host_info *sg_get_host_info()
82	+
83		ctypedef struct sg_cpu_stats:
84		long long user
85		long long kernel
#	Line 33 | Line 90 | cdef extern from "statgrab.h":
90		long long total
91		time_t systime
92
93	+	cdef extern sg_cpu_stats *sg_get_cpu_stats()
94	+	cdef extern sg_cpu_stats *sg_get_cpu_stats_diff()
95	+
96		ctypedef struct sg_cpu_percents:
97		float user
98		float kernel
#	Line 42 | Line 102 | cdef extern from "statgrab.h":
102		float nice
103		time_t time_taken
104
105	+	cdef extern sg_cpu_percents *sg_get_cpu_percents()
106	+
107		ctypedef struct sg_mem_stats:
108		long long total
109		long long free
110		long long used
111		long long cache
112
113	+	cdef extern sg_mem_stats *sg_get_mem_stats()
114	+
115		ctypedef struct sg_load_stats:
116		double min1
117		double min5
118		double min15
119
120	+	cdef extern sg_load_stats *sg_get_load_stats()
121	+
122		ctypedef struct sg_user_stats:
123		char *name_list
124		int num_entries
125
126	+	cdef extern sg_user_stats *sg_get_user_stats()
127	+
128		ctypedef struct sg_swap_stats:
129		long long total
130		long long used
131		long long free
132
133	<	ctypedef struct sg_host_info:
66	<	char *os_name
67	<	char *os_release
68	<	char *os_version
69	<	char *platform
70	<	char *hostname
71	<	time_t uptime
133	>	cdef extern sg_swap_stats *sg_get_swap_stats()
134
135		ctypedef struct sg_fs_stats:
136		char *device_name
#	Line 80 | Line 142 | cdef extern from "statgrab.h":
142		long long total_inodes
143		long long used_inodes
144		long long free_inodes
145	+	long long avail_inodes
146	+	long long io_size
147	+	long long block_size
148	+	long long total_blocks
149	+	long long free_blocks
150	+	long long used_blocks
151	+	long long avail_blocks
152
153	+	cdef extern sg_fs_stats *sg_get_fs_stats(int *entries)
154	+
155		ctypedef struct sg_disk_io_stats:
156		char *disk_name
157		long long read_bytes
158		long long write_bytes
159		time_t systime
160
161	<	ctypedef struct sg_process_count:
162	<	int total
92	<	int running
93	<	int sleeping
94	<	int stopped
95	<	int zombie
161	>	cdef extern sg_disk_io_stats *sg_get_disk_io_stats(int *entries)
162	>	cdef extern sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries)
163
164		ctypedef struct sg_network_io_stats:
165		char *interface_name
#	Line 105 | Line 172 | cdef extern from "statgrab.h":
172		long long collisions
173		time_t systime
174
175	+	cdef extern sg_network_io_stats *sg_get_network_io_stats(int *entries)
176	+	cdef extern sg_network_io_stats *sg_get_network_io_stats_diff(int *entries)
177	+
178		ctypedef enum sg_iface_duplex:
179		SG_IFACE_DUPLEX_FULL
180		SG_IFACE_DUPLEX_HALF
#	Line 113 | Line 183 | cdef extern from "statgrab.h":
183		ctypedef struct sg_network_iface_stats:
184		char *interface_name
185		int speed
186	<	sg_iface_duplex dup
186	>	sg_iface_duplex duplex
187		int up
188
189	+	cdef extern sg_network_iface_stats *sg_get_network_iface_stats(int *entries)
190	+
191		ctypedef struct sg_page_stats:
192		long long pages_pagein
193		long long pages_pageout
194		time_t systime
195
124	–	cdef extern sg_cpu_stats *sg_get_cpu_stats()
125	–	cdef extern sg_cpu_stats *sg_get_cpu_stats_diff()
126	–	cdef extern sg_cpu_percents *sg_get_cpu_percents()
127	–	cdef extern sg_mem_stats *sg_get_mem_stats()
128	–	cdef extern sg_load_stats *sg_get_load_stats()
129	–	cdef extern sg_user_stats *sg_get_user_stats()
130	–	cdef extern sg_swap_stats *sg_get_swap_stats()
131	–	cdef extern sg_host_info *sg_get_host_info()
132	–	cdef extern sg_fs_stats *sg_get_fs_stats(int *entries)
133	–	cdef extern sg_disk_io_stats *sg_get_disk_io_stats(int *entries)
134	–	cdef extern sg_disk_io_stats *sg_get_disk_io_stats_diff(int *entries)
135	–	cdef extern sg_process_count *sg_get_process_count()
136	–	cdef extern sg_network_io_stats *sg_get_network_io_stats(int *entries)
137	–	cdef extern sg_network_io_stats *sg_get_network_io_stats_diff(int *entries)
138	–	cdef extern sg_network_iface_stats *sg_get_network_iface_stats(int *entries)
196		cdef extern sg_page_stats *sg_get_page_stats()
197		cdef extern sg_page_stats *sg_get_page_stats_diff()
141	–	cdef extern int sg_init()
142	–	cdef extern int sg_drop_privileges()
198
199	+	ctypedef enum sg_process_state:
200	+	SG_PROCESS_STATE_RUNNING
201	+	SG_PROCESS_STATE_SLEEPING
202	+	SG_PROCESS_STATE_STOPPED
203	+	SG_PROCESS_STATE_ZOMBIE
204	+	SG_PROCESS_STATE_UNKNOWN
205
206	+	ctypedef struct sg_process_stats:
207	+	char *process_name
208	+	char *proctitle
209	+	pid_t pid
210	+	pid_t parent
211	+	pid_t pgid
212	+	uid_t uid
213	+	uid_t euid
214	+	gid_t gid
215	+	gid_t egid
216	+	unsigned long long proc_size
217	+	unsigned long long proc_resident
218	+	time_t time_spent
219	+	double cpu_percent
220	+	int nice
221	+	sg_process_state state
222	+
223	+	cdef extern sg_process_stats *sg_get_process_stats(int *entries)
224	+
225	+	ctypedef struct sg_process_count:
226	+	int total
227	+	int running
228	+	int sleeping
229	+	int stopped
230	+	int zombie
231	+
232	+	cdef extern sg_process_count *sg_get_process_count()
233	+
234	+
235	+	py_SG_ERROR_NONE = SG_ERROR_NONE
236	+	py_SG_ERROR_ASPRINTF = SG_ERROR_ASPRINTF
237	+	py_SG_ERROR_DEVSTAT_GETDEVS = SG_ERROR_DEVSTAT_GETDEVS
238	+	py_SG_ERROR_DEVSTAT_SELECTDEVS = SG_ERROR_DEVSTAT_SELECTDEVS
239	+	py_SG_ERROR_ENOENT = SG_ERROR_ENOENT
240	+	py_SG_ERROR_GETIFADDRS = SG_ERROR_GETIFADDRS
241	+	py_SG_ERROR_GETMNTINFO = SG_ERROR_GETMNTINFO
242	+	py_SG_ERROR_GETPAGESIZE = SG_ERROR_GETPAGESIZE
243	+	py_SG_ERROR_KSTAT_DATA_LOOKUP = SG_ERROR_KSTAT_DATA_LOOKUP
244	+	py_SG_ERROR_KSTAT_LOOKUP = SG_ERROR_KSTAT_LOOKUP
245	+	py_SG_ERROR_KSTAT_OPEN = SG_ERROR_KSTAT_OPEN
246	+	py_SG_ERROR_KSTAT_READ = SG_ERROR_KSTAT_READ
247	+	py_SG_ERROR_KVM_GETSWAPINFO = SG_ERROR_KVM_GETSWAPINFO
248	+	py_SG_ERROR_KVM_OPENFILES = SG_ERROR_KVM_OPENFILES
249	+	py_SG_ERROR_MALLOC = SG_ERROR_MALLOC
250	+	py_SG_ERROR_OPEN = SG_ERROR_OPEN
251	+	py_SG_ERROR_OPENDIR = SG_ERROR_OPENDIR
252	+	py_SG_ERROR_PARSE = SG_ERROR_PARSE
253	+	py_SG_ERROR_SETEGID = SG_ERROR_SETEGID
254	+	py_SG_ERROR_SETEUID = SG_ERROR_SETEUID
255	+	py_SG_ERROR_SETMNTENT = SG_ERROR_SETMNTENT
256	+	py_SG_ERROR_SOCKET = SG_ERROR_SOCKET
257	+	py_SG_ERROR_SWAPCTL = SG_ERROR_SWAPCTL
258	+	py_SG_ERROR_SYSCONF = SG_ERROR_SYSCONF
259	+	py_SG_ERROR_SYSCTL = SG_ERROR_SYSCTL
260	+	py_SG_ERROR_SYSCTLBYNAME = SG_ERROR_SYSCTLBYNAME
261	+	py_SG_ERROR_SYSCTLNAMETOMIB = SG_ERROR_SYSCTLNAMETOMIB
262	+	py_SG_ERROR_UNAME = SG_ERROR_UNAME
263	+	py_SG_ERROR_UNSUPPORTED = SG_ERROR_UNSUPPORTED
264	+	py_SG_ERROR_XSW_VER_MISMATCH = SG_ERROR_XSW_VER_MISMATCH
265	+
266		py_SG_IFACE_DUPLEX_FULL = SG_IFACE_DUPLEX_FULL
267		py_SG_IFACE_DUPLEX_HALF = SG_IFACE_DUPLEX_HALF
268		py_SG_IFACE_DUPLEX_UNKNOWN = SG_IFACE_DUPLEX_UNKNOWN
269
270	+	py_SG_PROCESS_STATE_RUNNING = SG_PROCESS_STATE_RUNNING
271	+	py_SG_PROCESS_STATE_SLEEPING = SG_PROCESS_STATE_SLEEPING
272	+	py_SG_PROCESS_STATE_STOPPED = SG_PROCESS_STATE_STOPPED
273	+	py_SG_PROCESS_STATE_ZOMBIE = SG_PROCESS_STATE_ZOMBIE
274	+	py_SG_PROCESS_STATE_UNKNOWN = SG_PROCESS_STATE_UNKNOWN
275
276	<	class Result:
276	>
277	>	class Result(dict):
278		def __init__(self, attrs):
279	<	self.attrs = attrs
280	<	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)
279	>	self.attrs = attrs # to maintain compatibility
280	>	super(Result, self).__init__(attrs)
281
282	+	def __getattr__(self, item):
283	+	try:
284	+	return self.__getitem__(item)
285	+	except KeyError:
286	+	raise AttributeError(item)
287	+
288		class StatgrabException(Exception):
289		def __init__(self, value):
290		self.value = value
#	Line 164 | Line 292 | class StatgrabException(Exception):
292		return repr(self.value)
293
294
295	+	def py_sg_init():
296	+	if sg_init() == 0:
297	+	return True
298	+	else:
299	+	return False
300	+
301	+	def py_sg_shutdown():
302	+	if sg_shutdown() == 0:
303	+	return True
304	+	else:
305	+	return False
306	+
307	+	def py_sg_snapshot():
308	+	if sg_snapshot() == 0:
309	+	return True
310	+	else:
311	+	return False
312	+
313	+	def py_sg_drop_privileges():
314	+	if sg_drop_privileges() == 0:
315	+	return True
316	+	else:
317	+	return False
318	+
319	+	def py_sg_set_error(code, arg):
320	+	sg_set_error(code, arg)
321	+
322	+	def py_sg_set_error_with_errno(code, arg):
323	+	sg_set_error_with_errno(code, arg)
324	+
325	+	def py_sg_get_error():
326	+	cdef sg_error s
327	+	s = sg_get_error()
328	+	return s
329	+
330	+	def py_sg_get_error_arg():
331	+	s = sg_get_error_arg()
332	+	return s
333	+
334	+	def py_sg_get_error_errno():
335	+	s = sg_get_error_errno()
336	+	return s
337	+
338	+	def py_sg_str_error(code):
339	+	s = sg_str_error(code)
340	+	return s
341	+
342	+	def py_sg_get_host_info():
343	+	cdef sg_host_info *s
344	+	s = sg_get_host_info()
345	+	if s == NULL:
346	+	raise StatgrabException, 'sg_get_host_info() returned NULL'
347	+	return Result(
348	+	{'os_name': s.os_name,
349	+	'os_release': s.os_release,
350	+	'os_version': s.os_version,
351	+	'platform': s.platform,
352	+	'hostname': s.hostname,
353	+	'uptime': s.uptime,
354	+	}
355	+	)
356	+
357		def py_sg_get_cpu_stats():
358		cdef sg_cpu_stats *s
359		s = sg_get_cpu_stats()
#	Line 262 | Line 452 | def py_sg_get_swap_stats():
452		}
453		)
454
265	–	def py_sg_get_host_info():
266	–	cdef sg_host_info *s
267	–	s = sg_get_host_info()
268	–	if s == NULL:
269	–	raise StatgrabException, 'sg_get_host_info() 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	–
455		def py_sg_get_fs_stats():
456		cdef sg_fs_stats *s
457		cdef int entries
#	Line 295 | Line 470 | def py_sg_get_fs_stats():
470		'total_inodes': s.total_inodes,
471		'used_inodes': s.used_inodes,
472		'free_inodes': s.free_inodes,
473	+	'avail_inodes': s.avail_inodes,
474	+	'io_size': s.io_size,
475	+	'block_size': s.block_size,
476	+	'total_blocks': s.total_blocks,
477	+	'free_blocks': s.free_blocks,
478	+	'used_blocks': s.used_blocks,
479	+	'avail_blocks': s.avail_blocks,
480		}
481		))
482		s = s + 1
#	Line 336 | Line 518 | def py_sg_get_disk_io_stats_diff():
518		s = s + 1
519		return list
520
339	–	def py_sg_get_process_count():
340	–	cdef sg_process_count *s
341	–	s = sg_get_process_count()
342	–	if s == NULL:
343	–	raise StatgrabException, 'sg_get_process_count() 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	–
521		def py_sg_get_network_io_stats():
522		cdef sg_network_io_stats *s
523		cdef int entries
#	Line 407 | Line 575 | def py_sg_get_network_iface_stats():
575		list.append(Result(
576		{'interface_name': s.interface_name,
577		'speed': s.speed,
578	<	'dup': s.dup,
578	>	'duplex': s.duplex,
579		'up' : s.up,
580		}
581		))
#	Line 436 | Line 604 | def py_sg_get_page_stats_diff():
604		}
605		)
606
607	<	def py_sg_init():
608	<	if sg_init() == 0:
609	<	return True
610	<	else:
611	<	return False
607	>	def py_sg_get_process_stats():
608	>	cdef sg_process_stats *s
609	>	cdef int entries
610	>	s = sg_get_process_stats(&entries)
611	>	if s == NULL:
612	>	raise StatgrabException, 'sg_get_process_stats() returned NULL'
613	>	list = []
614	>	for i from 0 <= i < entries:
615	>	if s.process_name is NULL:
616	>	process_name = ''
617	>	else:
618	>	process_name = s.process_name
619	>	if s.proctitle is NULL:
620	>	proctitle = ''
621	>	else:
622	>	proctitle = s.proctitle
623	>	list.append(Result(
624	>	{'process_name': process_name,
625	>	'proctitle' : proctitle,
626	>	'pid' : s.pid,
627	>	'parent' : s.parent,
628	>	'pgid' : s.pgid,
629	>	'uid' : s.uid,
630	>	'euid' : s.euid,
631	>	'gid' : s.gid,
632	>	'egid' : s.egid,
633	>	'proc_size' : s.proc_size,
634	>	'proc_resident' : s.proc_resident,
635	>	'time_spent' : s.time_spent,
636	>	'cpu_percent' : s.cpu_percent,
637	>	'nice' : s.nice,
638	>	'state' : s.state,
639	>	}
640	>	))
641	>	s = s + 1
642	>	return list
643
644	<	def py_sg_drop_privileges():
645	<	if sg_drop_privileges() == 0:
646	<	return True
647	<	else:
648	<	return False
644	>	def py_sg_get_process_count():
645	>	cdef sg_process_count *s
646	>	s = sg_get_process_count()
647	>	if s == NULL:
648	>	raise StatgrabException, 'sg_get_process_count() returned NULL'
649	>	return Result(
650	>	{'total': s.total,
651	>	'running': s.running,
652	>	'sleeping': s.sleeping,
653	>	'stopped': s.stopped,
654	>	'zombie': s.zombie,
655	>	}
656	>	)

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines