extras/python/statgrab.pyx

# TODO: deal with failures better (return nothing, or raise error?)

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
        time_t systime

    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 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()


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)


def py_get_cpu_totals():
    cdef cpu_states_t *s
    s = get_cpu_totals()
    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()
    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()
    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()
    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()
    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()
    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()
    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()
    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)
    list = [entries]
    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)
    list = [entries]
    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)
    list = [entries]
    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()
    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)
    list = [entries]
    for i from 0 <= i < entries:
        list.append(Result(
            {'interface_name': s.interface_name,
             'tx': s.tx,
             'rx': s.rx,
             '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)
    list = [entries]
    for i from 0 <= i < entries:
        list.append(Result(
            {'interface_name': s.interface_name,
             'tx': s.tx,
             'rx': s.rx,
             'systime': s.systime,
            }
        ))
        s = s + 1
    return list

def py_get_page_stats():
    cdef page_stat_t *s
    s = get_page_stats()
    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()
    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.2
Committed:	Fri Feb 6 15:12:14 2004 UTC (21 years, 10 months ago) by tdb
Branch:	MAIN
Changes since 1.1:	+135 -98 lines
Log Message:	Return objects instead of hash-like-things :)
#	Content
1	# TODO: deal with failures better (return nothing, or raise error?)
2
3	ctypedef long time_t
4
5	cdef extern from "statgrab.h":
6	ctypedef struct cpu_states_t:
7	long long user
8	long long kernel
9	long long idle
10	long long iowait
11	long long swap
12	long long nice
13	long long total
14	time_t systime
15
16	ctypedef struct cpu_percent_t:
17	float user
18	float kernel
19	float idle
20	float iowait
21	float swap
22	float nice
23	time_t time_taken
24
25	ctypedef struct mem_stat_t:
26	long long total
27	long long free
28	long long used
29	long long cache
30
31	ctypedef struct load_stat_t:
32	double min1
33	double min5
34	double min15
35
36	ctypedef struct user_stat_t:
37	char *name_list
38	int num_entries
39
40	ctypedef struct swap_stat_t:
41	long long total
42	long long used
43	long long free
44
45	ctypedef struct general_stat_t:
46	char *os_name
47	char *os_release
48	char *os_version
49	char *platform
50	char *hostname
51	time_t uptime
52
53	ctypedef struct disk_stat_t:
54	char *device_name
55	char *fs_type
56	char *mnt_point
57	long long size
58	long long used
59	long long avail
60	long long total_inodes
61	long long used_inodes
62	long long free_inodes
63
64	ctypedef struct diskio_stat_t:
65	char *disk_name
66	long long read_bytes
67	long long write_bytes
68	time_t systime
69
70	ctypedef struct process_stat_t:
71	int total
72	int running
73	int sleeping
74	int stopped
75	int zombie
76
77	ctypedef struct network_stat_t:
78	char *interface_name
79	long long tx
80	long long rx
81	time_t systime
82
83	ctypedef struct page_stat_t:
84	long long pages_pagein
85	long long pages_pageout
86	time_t systime
87
88	cdef extern cpu_states_t *get_cpu_totals()
89	cdef extern cpu_states_t *get_cpu_diff()
90	cdef extern cpu_percent_t *cpu_percent_usage()
91	cdef extern mem_stat_t *get_memory_stats()
92	cdef extern load_stat_t *get_load_stats()
93	cdef extern user_stat_t *get_user_stats()
94	cdef extern swap_stat_t *get_swap_stats()
95	cdef extern general_stat_t *get_general_stats()
96	cdef extern disk_stat_t get_disk_stats(int entries)
97	cdef extern diskio_stat_t get_diskio_stats(int entries)
98	cdef extern diskio_stat_t get_diskio_stats_diff(int entries)
99	cdef extern process_stat_t *get_process_stats()
100	cdef extern network_stat_t get_network_stats(int entries)
101	cdef extern network_stat_t get_network_stats_diff(int entries)
102	cdef extern page_stat_t *get_page_stats()
103	cdef extern page_stat_t *get_page_stats_diff()
104	cdef extern int statgrab_init()
105	cdef extern int statgrab_drop_privileges()
106
107
108	class Result:
109	def __init__(self, attrs):
110	self.attrs = attrs
111	for attr in attrs:
112	setattr(self, attr, attrs[attr])
113	def __getitem__(self, item):
114	return getattr(self, item)
115	def __repr__(self):
116	return str(self.attrs)
117
118
119	def py_get_cpu_totals():
120	cdef cpu_states_t *s
121	s = get_cpu_totals()
122	return Result(
123	{'user': s.user,
124	'kernel': s.kernel,
125	'idle': s.idle,
126	'iowait': s.iowait,
127	'swap': s.swap,
128	'nice': s.nice,
129	'total': s.total,
130	'systime': s.systime,
131	}
132	)
133
134	def py_get_cpu_diff():
135	cdef cpu_states_t *s
136	s = get_cpu_diff()
137	return Result(
138	{'user': s.user,
139	'kernel': s.kernel,
140	'idle': s.idle,
141	'iowait': s.iowait,
142	'swap': s.swap,
143	'nice': s.nice,
144	'total': s.total,
145	'systime': s.systime,
146	}
147	)
148
149	def py_cpu_percent_usage():
150	cdef cpu_percent_t *s
151	s = cpu_percent_usage()
152	return Result(
153	{'user': s.user,
154	'kernel': s.kernel,
155	'idle': s.idle,
156	'iowait': s.iowait,
157	'swap': s.swap,
158	'nice': s.nice,
159	'time_taken': s.time_taken,
160	}
161	)
162
163	def py_get_memory_stats():
164	cdef mem_stat_t *s
165	s = get_memory_stats()
166	return Result(
167	{'total': s.total,
168	'used': s.used,
169	'free': s.free,
170	'cache': s.cache,
171	}
172	)
173
174	def py_get_load_stats():
175	cdef load_stat_t *s
176	s = get_load_stats()
177	return Result(
178	{'min1': s.min1,
179	'min5': s.min5,
180	'min15': s.min15,
181	}
182	)
183
184	def py_get_user_stats():
185	cdef user_stat_t *s
186	s = get_user_stats()
187	return Result(
188	{'name_list': s.name_list,
189	'num_entries': s.num_entries,
190	}
191	)
192
193	def py_get_swap_stats():
194	cdef swap_stat_t *s
195	s = get_swap_stats()
196	return Result(
197	{'total': s.total,
198	'used': s.used,
199	'free': s.free,
200	}
201	)
202
203	def py_get_general_stats():
204	cdef general_stat_t *s
205	s = get_general_stats()
206	return Result(
207	{'os_name': s.os_name,
208	'os_release': s.os_release,
209	'os_version': s.os_version,
210	'platform': s.platform,
211	'hostname': s.hostname,
212	'uptime': s.uptime,
213	}
214	)
215
216	def py_get_disk_stats():
217	cdef disk_stat_t *s
218	cdef int entries
219	s = get_disk_stats(&entries)
220	list = [entries]
221	for i from 0 <= i < entries:
222	list.append(Result(
223	{'device_name': s.device_name,
224	'fs_type': s.fs_type,
225	'mnt_point': s.mnt_point,
226	'size': s.size,
227	'used': s.used,
228	'avail': s.avail,
229	'total_inodes': s.total_inodes,
230	'used_inodes': s.used_inodes,
231	'free_inodes': s.free_inodes,
232	}
233	))
234	s = s + 1
235	return list
236
237	def py_get_diskio_stats():
238	cdef diskio_stat_t *s
239	cdef int entries
240	s = get_diskio_stats(&entries)
241	list = [entries]
242	for i from 0 <= i < entries:
243	list.append(Result(
244	{'disk_name': s.disk_name,
245	'read_bytes': s.read_bytes,
246	'write_bytes': s.write_bytes,
247	'systime': s.systime,
248	}
249	))
250	s = s + 1
251	return list
252
253	def py_get_diskio_stats_diff():
254	cdef diskio_stat_t *s
255	cdef int entries
256	s = get_diskio_stats_diff(&entries)
257	list = [entries]
258	for i from 0 <= i < entries:
259	list.append(Result(
260	{'disk_name': s.disk_name,
261	'read_bytes': s.read_bytes,
262	'write_bytes': s.write_bytes,
263	'systime': s.systime,
264	}
265	))
266	s = s + 1
267	return list
268
269	def py_get_process_stats():
270	cdef process_stat_t *s
271	s = get_process_stats()
272	return Result(
273	{'total': s.total,
274	'running': s.running,
275	'sleeping': s.sleeping,
276	'stopped': s.stopped,
277	'zombie': s.zombie,
278	}
279	)
280
281	def py_get_network_stats():
282	cdef network_stat_t *s
283	cdef int entries
284	s = get_network_stats(&entries)
285	list = [entries]
286	for i from 0 <= i < entries:
287	list.append(Result(
288	{'interface_name': s.interface_name,
289	'tx': s.tx,
290	'rx': s.rx,
291	'systime': s.systime,
292	}
293	))
294	s = s + 1
295	return list
296
297	def py_get_network_stats_diff():
298	cdef network_stat_t *s
299	cdef int entries
300	s = get_network_stats_diff(&entries)
301	list = [entries]
302	for i from 0 <= i < entries:
303	list.append(Result(
304	{'interface_name': s.interface_name,
305	'tx': s.tx,
306	'rx': s.rx,
307	'systime': s.systime,
308	}
309	))
310	s = s + 1
311	return list
312
313	def py_get_page_stats():
314	cdef page_stat_t *s
315	s = get_page_stats()
316	return Result(
317	{'pages_pagein': s.pages_pagein,
318	'pages_pageout': s.pages_pageout,
319	}
320	)
321
322	def py_get_page_stats_diff():
323	cdef page_stat_t *s
324	s = get_page_stats_diff()
325	return Result(
326	{'pages_pagein': s.pages_pagein,
327	'pages_pageout': s.pages_pageout,
328	}
329	)
330
331	def py_statgrab_init():
332	return statgrab_init()
333
334	def py_statgrab_drop_privileges():
335	return statgrab_drop_privileges()