projects/pystatgrab/_statgrab.pyx

#
# i-scream pystatgrab
# http://www.i-scream.org/pystatgrab/
# 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.18 2005/09/14 18:15:44 ats 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 void sg_set_error_with_errno(sg_error code, char *arg)
    cdef extern sg_error sg_get_error()
    cdef extern char *sg_get_error_arg()
    cdef extern int sg_get_error_errno()
    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
        long long avail_inodes
        long long io_size
        long long block_size
        long long total_blocks
        long long free_blocks
        long long used_blocks
        long long avail_blocks

    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 duplex
        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_shutdown():
    if sg_shutdown() == 0:
        return True
    else:
        return False

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