ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/pystatgrab/_statgrab.pyx
(Generate patch)

Comparing projects/pystatgrab/_statgrab.pyx (file contents):
Revision 1.1 by tdb, Fri Feb 6 14:10:08 2004 UTC vs.
Revision 1.2 by tdb, Fri Feb 6 15:12:14 2004 UTC

# Line 1 | Line 1
1 < # TODO: return values more the python way - like os.stat
2 < #       deal with failures better (return nothing, or raise error?)
1 > # TODO: deal with failures better (return nothing, or raise error?)
2  
3   ctypedef long time_t
4  
# Line 106 | Line 105 | cdef extern from "statgrab.h":
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 {'user': s.user,
123 <            'kernel': s.kernel,
124 <            'idle': s.idle,
125 <            'iowait': s.iowait,
126 <            'swap': s.swap,
127 <            'nice': s.nice,
128 <            'total': s.total,
129 <            'systime': s.systime,
130 <           }
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 {'user': s.user,
138 <            'kernel': s.kernel,
139 <            'idle': s.idle,
140 <            'iowait': s.iowait,
141 <            'swap': s.swap,
142 <            'nice': s.nice,
143 <            'total': s.total,
144 <            'systime': s.systime,
145 <           }
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 {'user': s.user,
153 <            'kernel': s.kernel,
154 <            'idle': s.idle,
155 <            'iowait': s.iowait,
156 <            'swap': s.swap,
157 <            'nice': s.nice,
158 <            'time_taken': s.time_taken,
159 <           }
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 {'total': s.total,
167 <            'used': s.used,
168 <            'free': s.free,
169 <            'cache': s.cache,
170 <           }
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 {'min1': s.min1,
178 <            'min5': s.min5,
179 <            'min15': s.min15,
180 <           }
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 {'name_list': s.name_list,
188 <            'num_entries': s.num_entries,
189 <           }
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 {'total': s.total,
197 <            'used': s.used,
198 <            'free': s.free,
199 <           }
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 {'os_name': s.os_name,
207 <            'os_release': s.os_release,
208 <            'os_version': s.os_version,
209 <            'platform': s.platform,
210 <            'hostname': s.hostname,
211 <            'uptime': s.uptime,
212 <           }
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
# Line 193 | Line 219 | def py_get_disk_stats():
219      s = get_disk_stats(&entries)
220      list = [entries]
221      for i from 0 <= i < entries:
222 <        list.append({'device_name': s.device_name,
223 <                     'fs_type': s.fs_type,
224 <                     'mnt_point': s.mnt_point,
225 <                     'size': s.size,
226 <                     'used': s.used,
227 <                     'avail': s.avail,
228 <                     'total_inodes': s.total_inodes,
229 <                     'used_inodes': s.used_inodes,
230 <                     'free_inodes': s.free_inodes,
231 <                    },
232 <                   )
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  
# Line 213 | Line 240 | def py_get_diskio_stats():
240      s = get_diskio_stats(&entries)
241      list = [entries]
242      for i from 0 <= i < entries:
243 <        list.append({'disk_name': s.disk_name,
244 <                     'read_bytes': s.read_bytes,
245 <                     'write_bytes': s.write_bytes,
246 <                     'systime': s.systime,
247 <                    },
248 <                   )
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  
# Line 228 | Line 256 | def py_get_diskio_stats_diff():
256      s = get_diskio_stats_diff(&entries)
257      list = [entries]
258      for i from 0 <= i < entries:
259 <        list.append({'disk_name': s.disk_name,
260 <                     'read_bytes': s.read_bytes,
261 <                     'write_bytes': s.write_bytes,
262 <                     'systime': s.systime,
263 <                    },
264 <                   )
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 {'total': s.total,
273 <            'running': s.running,
274 <            'sleeping': s.sleeping,
275 <            'stopped': s.stopped,
276 <            'zombie': s.zombie,
277 <           }
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
# Line 253 | Line 284 | def py_get_network_stats():
284      s = get_network_stats(&entries)
285      list = [entries]
286      for i from 0 <= i < entries:
287 <        list.append({'interface_name': s.interface_name,
288 <                     'tx': s.tx,
289 <                     'rx': s.rx,
290 <                     'systime': s.systime,
291 <                    },
292 <                   )
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  
# Line 268 | Line 300 | def py_get_network_stats_diff():
300      s = get_network_stats_diff(&entries)
301      list = [entries]
302      for i from 0 <= i < entries:
303 <        list.append({'interface_name': s.interface_name,
304 <                     'tx': s.tx,
305 <                     'rx': s.rx,
306 <                     'systime': s.systime,
307 <                    },
308 <                   )
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 {'pages_pagein': s.pages_pagein,
317 <            'pages_pageout': s.pages_pageout,
318 <           }
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 {'pages_pagein': s.pages_pagein,
326 <            'pages_pageout': s.pages_pageout,
327 <           }
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()

Diff Legend

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