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.13 2004/05/30 15:32:28 tdb Exp $
#

ctypedef long time_t
ctypedef int pid_t
ctypedef int uid_t
ctypedef int gid_t

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

    ctypedef enum sg_error:
        SG_ERROR_NONE = 0
        SG_ERROR_ASPRINTF
        SG_ERROR_DEVSTAT_GETDEVS
        SG_ERROR_DEVSTAT_SELECTDEVS
        SG_ERROR_ENOENT
        SG_ERROR_GETIFADDRS
        SG_ERROR_GETMNTINFO
        SG_ERROR_GETPAGESIZE
        SG_ERROR_KSTAT_DATA_LOOKUP
        SG_ERROR_KSTAT_LOOKUP
        SG_ERROR_KSTAT_OPEN
        SG_ERROR_KSTAT_READ
        SG_ERROR_KVM_GETSWAPINFO
        SG_ERROR_KVM_OPENFILES
        SG_ERROR_MALLOC
        SG_ERROR_OPEN
        SG_ERROR_OPENDIR
        SG_ERROR_PARSE
        SG_ERROR_SETEGID
        SG_ERROR_SETEUID
        SG_ERROR_SETMNTENT
        SG_ERROR_SOCKET
        SG_ERROR_SWAPCTL
        SG_ERROR_SYSCONF
        SG_ERROR_SYSCTL
        SG_ERROR_SYSCTLBYNAME
        SG_ERROR_SYSCTLNAMETOMIB
        SG_ERROR_UNAME
        SG_ERROR_UNSUPPORTED
        SG_ERROR_XSW_VER_MISMATCH

    cdef extern void sg_set_error(sg_error code, char *arg)
    cdef extern sg_error sg_get_error()
    cdef extern char *sg_get_error_arg()
    cdef extern char *sg_str_error(sg_error code)

    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 enum sg_process_state:
        SG_PROCESS_STATE_RUNNING
        SG_PROCESS_STATE_SLEEPING
        SG_PROCESS_STATE_STOPPED
        SG_PROCESS_STATE_ZOMBIE
        SG_PROCESS_STATE_UNKNOWN

    ctypedef struct sg_process_stats:
        char *process_name
        char *proctitle
        pid_t pid
        pid_t parent
        pid_t pgid
        uid_t uid
        uid_t euid
        gid_t gid
        gid_t egid
        unsigned long long proc_size
        unsigned long long proc_resident
        time_t time_spent
        double cpu_percent
        int nice
        sg_process_state state

    cdef extern sg_process_stats *sg_get_process_stats(int *entries)

    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_ERROR_NONE = SG_ERROR_NONE
py_SG_ERROR_ASPRINTF = SG_ERROR_ASPRINTF
py_SG_ERROR_DEVSTAT_GETDEVS = SG_ERROR_DEVSTAT_GETDEVS
py_SG_ERROR_DEVSTAT_SELECTDEVS = SG_ERROR_DEVSTAT_SELECTDEVS
py_SG_ERROR_ENOENT = SG_ERROR_ENOENT
py_SG_ERROR_GETIFADDRS = SG_ERROR_GETIFADDRS
py_SG_ERROR_GETMNTINFO = SG_ERROR_GETMNTINFO
py_SG_ERROR_GETPAGESIZE = SG_ERROR_GETPAGESIZE
py_SG_ERROR_KSTAT_DATA_LOOKUP = SG_ERROR_KSTAT_DATA_LOOKUP
py_SG_ERROR_KSTAT_LOOKUP = SG_ERROR_KSTAT_LOOKUP
py_SG_ERROR_KSTAT_OPEN = SG_ERROR_KSTAT_OPEN
py_SG_ERROR_KSTAT_READ = SG_ERROR_KSTAT_READ
py_SG_ERROR_KVM_GETSWAPINFO = SG_ERROR_KVM_GETSWAPINFO
py_SG_ERROR_KVM_OPENFILES = SG_ERROR_KVM_OPENFILES
py_SG_ERROR_MALLOC = SG_ERROR_MALLOC
py_SG_ERROR_OPEN = SG_ERROR_OPEN
py_SG_ERROR_OPENDIR = SG_ERROR_OPENDIR
py_SG_ERROR_PARSE = SG_ERROR_PARSE
py_SG_ERROR_SETEGID = SG_ERROR_SETEGID
py_SG_ERROR_SETEUID = SG_ERROR_SETEUID
py_SG_ERROR_SETMNTENT = SG_ERROR_SETMNTENT
py_SG_ERROR_SOCKET = SG_ERROR_SOCKET
py_SG_ERROR_SWAPCTL = SG_ERROR_SWAPCTL
py_SG_ERROR_SYSCONF = SG_ERROR_SYSCONF
py_SG_ERROR_SYSCTL = SG_ERROR_SYSCTL
py_SG_ERROR_SYSCTLBYNAME = SG_ERROR_SYSCTLBYNAME
py_SG_ERROR_SYSCTLNAMETOMIB = SG_ERROR_SYSCTLNAMETOMIB
py_SG_ERROR_UNAME = SG_ERROR_UNAME
py_SG_ERROR_UNSUPPORTED = SG_ERROR_UNSUPPORTED
py_SG_ERROR_XSW_VER_MISMATCH = SG_ERROR_XSW_VER_MISMATCH

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

py_SG_PROCESS_STATE_RUNNING = SG_PROCESS_STATE_RUNNING
py_SG_PROCESS_STATE_SLEEPING = SG_PROCESS_STATE_SLEEPING
py_SG_PROCESS_STATE_STOPPED = SG_PROCESS_STATE_STOPPED
py_SG_PROCESS_STATE_ZOMBIE = SG_PROCESS_STATE_ZOMBIE
py_SG_PROCESS_STATE_UNKNOWN = SG_PROCESS_STATE_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_set_error(code, arg):
    sg_set_error(code, arg)

def py_sg_get_error():
    cdef sg_error s
    s = sg_get_error()
    return s

def py_sg_get_error_arg():
    s = sg_get_error_arg()
    return s

def py_sg_str_error(code):
    s = sg_str_error(code)
    return s

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_stats():
    cdef sg_process_stats *s
    cdef int entries
    s = sg_get_process_stats(&entries)
    if s == NULL:
        raise StatgrabException, 'sg_get_process_stats() returned NULL'
    list = []
    for i from 0 <= i < entries:
        if s.process_name == NULL:
            s.process_name = ''
        if s.proctitle == NULL:
            s.proctitle = ''
        list.append(Result(
            {'process_name': s.process_name,
             'proctitle' : s.proctitle,
             'pid' : s.pid,
             'parent' : s.parent,
             'pgid' : s.pgid,
             'uid' : s.uid,
             'euid' : s.euid,
             'gid' : s.gid,
             'egid' : s.egid,
             'proc_size' : s.proc_size,
             'proc_resident' : s.proc_resident,
             'time_spent' : s.time_spent,
             'cpu_percent' : s.cpu_percent,
             'nice' : s.nice,
             'state' : s.state,
            }
        ))
        s = s + 1
    return list

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.14
Committed:	Sun May 30 16:41:03 2004 UTC (19 years, 11 months ago) by tdb
Branch:	MAIN
CVS Tags:	PYSTATGRAB_0_2
Changes since 1.13:	+153 -1 lines
Log Message:	Stage 3: Add new functions.
#	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.14	# $Id: _statgrab.pyx,v 1.13 2004/05/30 15:32:28 tdb Exp $
21	tdb	1.3	#
22	tdb	1.1
23			ctypedef long time_t
24	tdb	1.14	ctypedef int pid_t
25			ctypedef int uid_t
26			ctypedef int gid_t
27	tdb	1.1
28			cdef extern from "statgrab.h":
29	tdb	1.13	cdef extern int sg_init()
30			cdef extern int sg_drop_privileges()
31
32	tdb	1.14	ctypedef enum sg_error:
33			SG_ERROR_NONE = 0
34			SG_ERROR_ASPRINTF
35			SG_ERROR_DEVSTAT_GETDEVS
36			SG_ERROR_DEVSTAT_SELECTDEVS
37			SG_ERROR_ENOENT
38			SG_ERROR_GETIFADDRS
39			SG_ERROR_GETMNTINFO
40			SG_ERROR_GETPAGESIZE
41			SG_ERROR_KSTAT_DATA_LOOKUP
42			SG_ERROR_KSTAT_LOOKUP
43			SG_ERROR_KSTAT_OPEN
44			SG_ERROR_KSTAT_READ
45			SG_ERROR_KVM_GETSWAPINFO
46			SG_ERROR_KVM_OPENFILES
47			SG_ERROR_MALLOC
48			SG_ERROR_OPEN
49			SG_ERROR_OPENDIR
50			SG_ERROR_PARSE
51			SG_ERROR_SETEGID
52			SG_ERROR_SETEUID
53			SG_ERROR_SETMNTENT
54			SG_ERROR_SOCKET
55			SG_ERROR_SWAPCTL
56			SG_ERROR_SYSCONF
57			SG_ERROR_SYSCTL
58			SG_ERROR_SYSCTLBYNAME
59			SG_ERROR_SYSCTLNAMETOMIB
60			SG_ERROR_UNAME
61			SG_ERROR_UNSUPPORTED
62			SG_ERROR_XSW_VER_MISMATCH
63
64			cdef extern void sg_set_error(sg_error code, char *arg)
65			cdef extern sg_error sg_get_error()
66			cdef extern char *sg_get_error_arg()
67			cdef extern char *sg_str_error(sg_error code)
68
69	tdb	1.13	ctypedef struct sg_host_info:
70			char *os_name
71			char *os_release
72			char *os_version
73			char *platform
74			char *hostname
75			time_t uptime
76
77			cdef extern sg_host_info *sg_get_host_info()
78
79	tdb	1.12	ctypedef struct sg_cpu_stats:
80	tdb	1.1	long long user
81			long long kernel
82			long long idle
83			long long iowait
84			long long swap
85			long long nice
86			long long total
87			time_t systime
88
89	tdb	1.13	cdef extern sg_cpu_stats *sg_get_cpu_stats()
90			cdef extern sg_cpu_stats *sg_get_cpu_stats_diff()
91
92	tdb	1.12	ctypedef struct sg_cpu_percents:
93	tdb	1.1	float user
94			float kernel
95			float idle
96			float iowait
97			float swap
98			float nice
99			time_t time_taken
100
101	tdb	1.13	cdef extern sg_cpu_percents *sg_get_cpu_percents()
102
103	tdb	1.12	ctypedef struct sg_mem_stats:
104	tdb	1.1	long long total
105			long long free
106			long long used
107			long long cache
108
109	tdb	1.13	cdef extern sg_mem_stats *sg_get_mem_stats()
110
111	tdb	1.12	ctypedef struct sg_load_stats:
112	tdb	1.1	double min1
113			double min5
114			double min15
115
116	tdb	1.13	cdef extern sg_load_stats *sg_get_load_stats()
117
118	tdb	1.12	ctypedef struct sg_user_stats:
119	tdb	1.1	char *name_list
120			int num_entries
121
122	tdb	1.13	cdef extern sg_user_stats *sg_get_user_stats()
123
124	tdb	1.12	ctypedef struct sg_swap_stats:
125	tdb	1.1	long long total
126			long long used
127			long long free
128
129	tdb	1.13	cdef extern sg_swap_stats *sg_get_swap_stats()
130	tdb	1.1
131	tdb	1.12	ctypedef struct sg_fs_stats:
132	tdb	1.1	char *device_name
133			char *fs_type
134			char *mnt_point
135			long long size
136			long long used
137			long long avail
138			long long total_inodes
139			long long used_inodes
140			long long free_inodes
141
142	tdb	1.13	cdef extern sg_fs_stats sg_get_fs_stats(int entries)
143
144	tdb	1.12	ctypedef struct sg_disk_io_stats:
145	tdb	1.1	char *disk_name
146			long long read_bytes
147			long long write_bytes
148			time_t systime
149
150	tdb	1.13	cdef extern sg_disk_io_stats sg_get_disk_io_stats(int entries)
151			cdef extern sg_disk_io_stats sg_get_disk_io_stats_diff(int entries)
152	tdb	1.1
153	tdb	1.12	ctypedef struct sg_network_io_stats:
154	tdb	1.1	char *interface_name
155			long long tx
156			long long rx
157	tdb	1.9	long long ipackets
158			long long opackets
159			long long ierrors
160			long long oerrors
161			long long collisions
162	tdb	1.1	time_t systime
163
164	tdb	1.13	cdef extern sg_network_io_stats sg_get_network_io_stats(int entries)
165			cdef extern sg_network_io_stats sg_get_network_io_stats_diff(int entries)
166
167	tdb	1.12	ctypedef enum sg_iface_duplex:
168			SG_IFACE_DUPLEX_FULL
169			SG_IFACE_DUPLEX_HALF
170			SG_IFACE_DUPLEX_UNKNOWN
171	tdb	1.5
172	tdb	1.12	ctypedef struct sg_network_iface_stats:
173	tdb	1.5	char *interface_name
174			int speed
175	tdb	1.12	sg_iface_duplex dup
176	tdb	1.8	int up
177	tdb	1.5
178	tdb	1.13	cdef extern sg_network_iface_stats sg_get_network_iface_stats(int entries)
179
180	tdb	1.12	ctypedef struct sg_page_stats:
181	tdb	1.1	long long pages_pagein
182			long long pages_pageout
183			time_t systime
184
185	tdb	1.12	cdef extern sg_page_stats *sg_get_page_stats()
186			cdef extern sg_page_stats *sg_get_page_stats_diff()
187	tdb	1.13
188	tdb	1.14	ctypedef enum sg_process_state:
189			SG_PROCESS_STATE_RUNNING
190			SG_PROCESS_STATE_SLEEPING
191			SG_PROCESS_STATE_STOPPED
192			SG_PROCESS_STATE_ZOMBIE
193			SG_PROCESS_STATE_UNKNOWN
194
195			ctypedef struct sg_process_stats:
196			char *process_name
197			char *proctitle
198			pid_t pid
199			pid_t parent
200			pid_t pgid
201			uid_t uid
202			uid_t euid
203			gid_t gid
204			gid_t egid
205			unsigned long long proc_size
206			unsigned long long proc_resident
207			time_t time_spent
208			double cpu_percent
209			int nice
210			sg_process_state state
211
212			cdef extern sg_process_stats sg_get_process_stats(int entries)
213
214	tdb	1.13	ctypedef struct sg_process_count:
215			int total
216			int running
217			int sleeping
218			int stopped
219			int zombie
220
221			cdef extern sg_process_count *sg_get_process_count()
222	tdb	1.12
223
224	tdb	1.14	py_SG_ERROR_NONE = SG_ERROR_NONE
225			py_SG_ERROR_ASPRINTF = SG_ERROR_ASPRINTF
226			py_SG_ERROR_DEVSTAT_GETDEVS = SG_ERROR_DEVSTAT_GETDEVS
227			py_SG_ERROR_DEVSTAT_SELECTDEVS = SG_ERROR_DEVSTAT_SELECTDEVS
228			py_SG_ERROR_ENOENT = SG_ERROR_ENOENT
229			py_SG_ERROR_GETIFADDRS = SG_ERROR_GETIFADDRS
230			py_SG_ERROR_GETMNTINFO = SG_ERROR_GETMNTINFO
231			py_SG_ERROR_GETPAGESIZE = SG_ERROR_GETPAGESIZE
232			py_SG_ERROR_KSTAT_DATA_LOOKUP = SG_ERROR_KSTAT_DATA_LOOKUP
233			py_SG_ERROR_KSTAT_LOOKUP = SG_ERROR_KSTAT_LOOKUP
234			py_SG_ERROR_KSTAT_OPEN = SG_ERROR_KSTAT_OPEN
235			py_SG_ERROR_KSTAT_READ = SG_ERROR_KSTAT_READ
236			py_SG_ERROR_KVM_GETSWAPINFO = SG_ERROR_KVM_GETSWAPINFO
237			py_SG_ERROR_KVM_OPENFILES = SG_ERROR_KVM_OPENFILES
238			py_SG_ERROR_MALLOC = SG_ERROR_MALLOC
239			py_SG_ERROR_OPEN = SG_ERROR_OPEN
240			py_SG_ERROR_OPENDIR = SG_ERROR_OPENDIR
241			py_SG_ERROR_PARSE = SG_ERROR_PARSE
242			py_SG_ERROR_SETEGID = SG_ERROR_SETEGID
243			py_SG_ERROR_SETEUID = SG_ERROR_SETEUID
244			py_SG_ERROR_SETMNTENT = SG_ERROR_SETMNTENT
245			py_SG_ERROR_SOCKET = SG_ERROR_SOCKET
246			py_SG_ERROR_SWAPCTL = SG_ERROR_SWAPCTL
247			py_SG_ERROR_SYSCONF = SG_ERROR_SYSCONF
248			py_SG_ERROR_SYSCTL = SG_ERROR_SYSCTL
249			py_SG_ERROR_SYSCTLBYNAME = SG_ERROR_SYSCTLBYNAME
250			py_SG_ERROR_SYSCTLNAMETOMIB = SG_ERROR_SYSCTLNAMETOMIB
251			py_SG_ERROR_UNAME = SG_ERROR_UNAME
252			py_SG_ERROR_UNSUPPORTED = SG_ERROR_UNSUPPORTED
253			py_SG_ERROR_XSW_VER_MISMATCH = SG_ERROR_XSW_VER_MISMATCH
254
255	tdb	1.12	py_SG_IFACE_DUPLEX_FULL = SG_IFACE_DUPLEX_FULL
256			py_SG_IFACE_DUPLEX_HALF = SG_IFACE_DUPLEX_HALF
257			py_SG_IFACE_DUPLEX_UNKNOWN = SG_IFACE_DUPLEX_UNKNOWN
258	tdb	1.1
259	tdb	1.14	py_SG_PROCESS_STATE_RUNNING = SG_PROCESS_STATE_RUNNING
260			py_SG_PROCESS_STATE_SLEEPING = SG_PROCESS_STATE_SLEEPING
261			py_SG_PROCESS_STATE_STOPPED = SG_PROCESS_STATE_STOPPED
262			py_SG_PROCESS_STATE_ZOMBIE = SG_PROCESS_STATE_ZOMBIE
263			py_SG_PROCESS_STATE_UNKNOWN = SG_PROCESS_STATE_UNKNOWN
264
265	tdb	1.1
266	tdb	1.2	class Result:
267			def __init__(self, attrs):
268			self.attrs = attrs
269			for attr in attrs:
270			setattr(self, attr, attrs[attr])
271			def __getitem__(self, item):
272			return getattr(self, item)
273			def __repr__(self):
274			return str(self.attrs)
275
276	tdb	1.4	class StatgrabException(Exception):
277	tdb	1.3	def __init__(self, value):
278			self.value = value
279			def __str__(self):
280			return repr(self.value)
281
282	tdb	1.2
283	tdb	1.13	def py_sg_init():
284			if sg_init() == 0:
285			return True
286			else:
287			return False
288
289			def py_sg_drop_privileges():
290			if sg_drop_privileges() == 0:
291			return True
292			else:
293			return False
294
295	tdb	1.14	def py_sg_set_error(code, arg):
296			sg_set_error(code, arg)
297
298			def py_sg_get_error():
299			cdef sg_error s
300			s = sg_get_error()
301			return s
302
303			def py_sg_get_error_arg():
304			s = sg_get_error_arg()
305			return s
306
307			def py_sg_str_error(code):
308			s = sg_str_error(code)
309			return s
310
311	tdb	1.13	def py_sg_get_host_info():
312			cdef sg_host_info *s
313			s = sg_get_host_info()
314			if s == NULL:
315			raise StatgrabException, 'sg_get_host_info() returned NULL'
316			return Result(
317			{'os_name': s.os_name,
318			'os_release': s.os_release,
319			'os_version': s.os_version,
320			'platform': s.platform,
321			'hostname': s.hostname,
322			'uptime': s.uptime,
323			}
324			)
325
326	tdb	1.12	def py_sg_get_cpu_stats():
327			cdef sg_cpu_stats *s
328			s = sg_get_cpu_stats()
329	tdb	1.3	if s == NULL:
330	tdb	1.12	raise StatgrabException, 'sg_get_cpu_stats() returned NULL'
331	tdb	1.2	return Result(
332			{'user': s.user,
333			'kernel': s.kernel,
334			'idle': s.idle,
335			'iowait': s.iowait,
336			'swap': s.swap,
337			'nice': s.nice,
338			'total': s.total,
339			'systime': s.systime,
340			}
341			)
342	tdb	1.1
343	tdb	1.12	def py_sg_get_cpu_stats_diff():
344			cdef sg_cpu_stats *s
345			s = sg_get_cpu_stats_diff()
346	tdb	1.3	if s == NULL:
347	tdb	1.12	raise StatgrabException, 'sg_get_cpu_stats_diff() returned NULL'
348	tdb	1.2	return Result(
349			{'user': s.user,
350			'kernel': s.kernel,
351			'idle': s.idle,
352			'iowait': s.iowait,
353			'swap': s.swap,
354			'nice': s.nice,
355			'total': s.total,
356			'systime': s.systime,
357			}
358			)
359	tdb	1.1
360	tdb	1.12	def py_sg_get_cpu_percents():
361			cdef sg_cpu_percents *s
362			s = sg_get_cpu_percents()
363	tdb	1.3	if s == NULL:
364	tdb	1.12	raise StatgrabException, 'sg_get_cpu_percents() returned NULL'
365	tdb	1.2	return Result(
366			{'user': s.user,
367			'kernel': s.kernel,
368			'idle': s.idle,
369			'iowait': s.iowait,
370			'swap': s.swap,
371			'nice': s.nice,
372			'time_taken': s.time_taken,
373			}
374			)
375	tdb	1.1
376	tdb	1.12	def py_sg_get_mem_stats():
377			cdef sg_mem_stats *s
378			s = sg_get_mem_stats()
379	tdb	1.3	if s == NULL:
380	tdb	1.12	raise StatgrabException, 'sg_get_mem_stats() returned NULL'
381	tdb	1.2	return Result(
382			{'total': s.total,
383			'used': s.used,
384			'free': s.free,
385			'cache': s.cache,
386			}
387			)
388	tdb	1.1
389	tdb	1.12	def py_sg_get_load_stats():
390			cdef sg_load_stats *s
391			s = sg_get_load_stats()
392	tdb	1.3	if s == NULL:
393	tdb	1.12	raise StatgrabException, 'sg_get_load_stats() returned NULL'
394	tdb	1.2	return Result(
395			{'min1': s.min1,
396			'min5': s.min5,
397			'min15': s.min15,
398			}
399			)
400	tdb	1.1
401	tdb	1.12	def py_sg_get_user_stats():
402			cdef sg_user_stats *s
403			s = sg_get_user_stats()
404	tdb	1.3	if s == NULL:
405	tdb	1.12	raise StatgrabException, 'sg_get_user_stats() returned NULL'
406	tdb	1.2	return Result(
407			{'name_list': s.name_list,
408			'num_entries': s.num_entries,
409			}
410			)
411	tdb	1.1
412	tdb	1.12	def py_sg_get_swap_stats():
413			cdef sg_swap_stats *s
414			s = sg_get_swap_stats()
415	tdb	1.3	if s == NULL:
416	tdb	1.12	raise StatgrabException, 'sg_get_swap_stats() returned NULL'
417	tdb	1.2	return Result(
418			{'total': s.total,
419			'used': s.used,
420			'free': s.free,
421			}
422			)
423	tdb	1.1
424	tdb	1.12	def py_sg_get_fs_stats():
425			cdef sg_fs_stats *s
426	tdb	1.1	cdef int entries
427	tdb	1.12	s = sg_get_fs_stats(&entries)
428	tdb	1.3	if s == NULL:
429	tdb	1.12	raise StatgrabException, 'sg_get_fs_stats() returned NULL'
430	tdb	1.6	list = []
431	tdb	1.1	for i from 0 <= i < entries:
432	tdb	1.2	list.append(Result(
433			{'device_name': s.device_name,
434			'fs_type': s.fs_type,
435			'mnt_point': s.mnt_point,
436			'size': s.size,
437			'used': s.used,
438			'avail': s.avail,
439			'total_inodes': s.total_inodes,
440			'used_inodes': s.used_inodes,
441			'free_inodes': s.free_inodes,
442			}
443			))
444	tdb	1.1	s = s + 1
445			return list
446
447	tdb	1.12	def py_sg_get_disk_io_stats():
448			cdef sg_disk_io_stats *s
449	tdb	1.1	cdef int entries
450	tdb	1.12	s = sg_get_disk_io_stats(&entries)
451	tdb	1.3	if s == NULL:
452	tdb	1.12	raise StatgrabException, 'sg_get_disk_io_stats() returned NULL'
453	tdb	1.6	list = []
454	tdb	1.1	for i from 0 <= i < entries:
455	tdb	1.2	list.append(Result(
456			{'disk_name': s.disk_name,
457			'read_bytes': s.read_bytes,
458			'write_bytes': s.write_bytes,
459			'systime': s.systime,
460			}
461			))
462	tdb	1.1	s = s + 1
463			return list
464
465	tdb	1.12	def py_sg_get_disk_io_stats_diff():
466			cdef sg_disk_io_stats *s
467	tdb	1.1	cdef int entries
468	tdb	1.12	s = sg_get_disk_io_stats_diff(&entries)
469	tdb	1.3	if s == NULL:
470	tdb	1.12	raise StatgrabException, 'sg_get_disk_io_stats_diff() returned NULL'
471	tdb	1.6	list = []
472	tdb	1.1	for i from 0 <= i < entries:
473	tdb	1.2	list.append(Result(
474			{'disk_name': s.disk_name,
475			'read_bytes': s.read_bytes,
476			'write_bytes': s.write_bytes,
477			'systime': s.systime,
478			}
479			))
480	tdb	1.1	s = s + 1
481			return list
482
483	tdb	1.12	def py_sg_get_network_io_stats():
484			cdef sg_network_io_stats *s
485	tdb	1.1	cdef int entries
486	tdb	1.12	s = sg_get_network_io_stats(&entries)
487	tdb	1.3	if s == NULL:
488	tdb	1.12	raise StatgrabException, 'sg_get_network_io_stats() returned NULL'
489	tdb	1.6	list = []
490	tdb	1.1	for i from 0 <= i < entries:
491	tdb	1.2	list.append(Result(
492			{'interface_name': s.interface_name,
493			'tx': s.tx,
494			'rx': s.rx,
495	tdb	1.9	'ipackets': s.ipackets,
496			'opackets': s.opackets,
497			'ierrors': s.ierrors,
498			'oerrors': s.oerrors,
499			'collisions': s.collisions,
500	tdb	1.2	'systime': s.systime,
501			}
502			))
503	tdb	1.1	s = s + 1
504			return list
505
506	tdb	1.12	def py_sg_get_network_io_stats_diff():
507			cdef sg_network_io_stats *s
508	tdb	1.1	cdef int entries
509	tdb	1.12	s = sg_get_network_io_stats_diff(&entries)
510	tdb	1.3	if s == NULL:
511	tdb	1.12	raise StatgrabException, 'sg_get_network_io_stats_diff() returned NULL'
512	tdb	1.6	list = []
513	tdb	1.1	for i from 0 <= i < entries:
514	tdb	1.2	list.append(Result(
515			{'interface_name': s.interface_name,
516			'tx': s.tx,
517			'rx': s.rx,
518	tdb	1.9	'ipackets': s.ipackets,
519			'opackets': s.opackets,
520			'ierrors': s.ierrors,
521			'oerrors': s.oerrors,
522			'collisions': s.collisions,
523	tdb	1.2	'systime': s.systime,
524	tdb	1.5	}
525			))
526			s = s + 1
527			return list
528
529	tdb	1.12	def py_sg_get_network_iface_stats():
530			cdef sg_network_iface_stats *s
531	tdb	1.5	cdef int entries
532	tdb	1.12	s = sg_get_network_iface_stats(&entries)
533	tdb	1.5	if s == NULL:
534	tdb	1.12	raise StatgrabException, 'sg_get_network_iface_stats() returned NULL'
535	tdb	1.6	list = []
536	tdb	1.5	for i from 0 <= i < entries:
537			list.append(Result(
538			{'interface_name': s.interface_name,
539			'speed': s.speed,
540			'dup': s.dup,
541	tdb	1.8	'up' : s.up,
542	tdb	1.2	}
543			))
544	tdb	1.1	s = s + 1
545			return list
546
547	tdb	1.12	def py_sg_get_page_stats():
548			cdef sg_page_stats *s
549			s = sg_get_page_stats()
550	tdb	1.3	if s == NULL:
551	tdb	1.12	raise StatgrabException, 'sg_get_page_stats() returned NULL'
552	tdb	1.2	return Result(
553			{'pages_pagein': s.pages_pagein,
554			'pages_pageout': s.pages_pageout,
555			}
556			)
557	tdb	1.1
558	tdb	1.12	def py_sg_get_page_stats_diff():
559			cdef sg_page_stats *s
560			s = sg_get_page_stats_diff()
561	tdb	1.3	if s == NULL:
562	tdb	1.12	raise StatgrabException, 'sg_get_page_stats_diff() returned NULL'
563	tdb	1.2	return Result(
564			{'pages_pagein': s.pages_pagein,
565			'pages_pageout': s.pages_pageout,
566			}
567			)
568	tdb	1.14
569			def py_sg_get_process_stats():
570			cdef sg_process_stats *s
571			cdef int entries
572			s = sg_get_process_stats(&entries)
573			if s == NULL:
574			raise StatgrabException, 'sg_get_process_stats() returned NULL'
575			list = []
576			for i from 0 <= i < entries:
577			if s.process_name == NULL:
578			s.process_name = ''
579			if s.proctitle == NULL:
580			s.proctitle = ''
581			list.append(Result(
582			{'process_name': s.process_name,
583			'proctitle' : s.proctitle,
584			'pid' : s.pid,
585			'parent' : s.parent,
586			'pgid' : s.pgid,
587			'uid' : s.uid,
588			'euid' : s.euid,
589			'gid' : s.gid,
590			'egid' : s.egid,
591			'proc_size' : s.proc_size,
592			'proc_resident' : s.proc_resident,
593			'time_spent' : s.time_spent,
594			'cpu_percent' : s.cpu_percent,
595			'nice' : s.nice,
596			'state' : s.state,
597			}
598			))
599			s = s + 1
600			return list
601	tdb	1.1
602	tdb	1.13	def py_sg_get_process_count():
603			cdef sg_process_count *s
604			s = sg_get_process_count()
605			if s == NULL:
606			raise StatgrabException, 'sg_get_process_count() returned NULL'
607			return Result(
608			{'total': s.total,
609			'running': s.running,
610			'sleeping': s.sleeping,
611			'stopped': s.stopped,
612			'zombie': s.zombie,
613			}
614			)