1

from qmsk.net.lib.event2.event cimport *

     2

from qmsk.net.lib.event2.base cimport event_base

     3

     4

cdef lib.timeval* build_timeout (lib.timeval *tv, object timeout = None) except? <lib.timeval *>-1 :

     5

    """

     6

        If a timeout is given, it is treated as a float and stored in *tv, which is returned. Otherwise, simply returns

     7

        NULL.

     8

    """

     9

    10

    cdef double t

    11

    12

    if timeout is not None :

    13

        t = timeout

    14

    15

        tv.tv_sec = <int>(t)

    16

        tv.tv_usec = <int>((t - <int> t) * 100000)

    17

    18

        return tv

    19

    20

    else :

    21

        return NULL

    22

    23

    24

# our shared callback handler

    25

# this must aquire the GIL before invoking the python object

    26

# this means that the libevent loop *must* be run with the GIL released!

    27

cdef void ev_callback (lib.evutil_socket_t fd, short mask, void *arg) with gil :

    28

    """

    29

        Proxy event back to event object passed as arg

    30

    """

    31

    32

    # unpack opaque arg

    33

    cdef event ev = <event>arg

    34

    35

    # invoke

    36

    # XXX: logging?

    37

    ev(fd, mask)

    38

    39

    40

cdef class event :

    41

    47

    48

        # construct event using our internal callback, with self as the arg

    49

        self.ev = lib.event_new(base.ev_base, fd, events, ev_callback, <void *>self)

    50

    51

        if self.ev == NULL :

    52

            raise Exception("event_new")

    53

    54

    56

        """

    57

            Re-assign our event parameters to the given ones.

    58

    59

            It is illegal to call this method after calling .add() but before del()/callback!

    60

        """

    61

    62

        # interesting... no error return code

    63

        lib.event_assign(self.ev, base.ev_base, fd, events, ev_callback, <void *>self)

    64

    65

    66

    def add (self, timeout = None) :

    67

        """

    68

            Add this event to our event_base's set of monitored events.

    69

    70

            This event will be executed if any of the events specified in 'events' occurs, or the given timeout

    71

            expires. If no timeout is given, no timeout will occur.

    72

    73

            If this event already has a shceduled timeout, the old timeout will be replaced by the new one.

    74

    75

                timeout     - a float representing the timeout length

    76

    77

            XXX: "The event in the ev argument must be already initialized by event_set() and may not be used in calls to event_set() until it has timed out or been removed with event_del()" -- enforce

    78

        """

    79

    80

        cdef lib.timeval tv

    81

    82

        if lib.event_add(self.ev, build_timeout(&tv, timeout)) < 0 :

    83

            raise Exception("event_new")

    84

    85

    86

    def delete (self) :

    87

        """

    88

            Remove this event from our event_base's set of monitored events.

    89

    90

            If this event has already executed or has never been added this call with have no effect.

    91

        """

    92

    93

        if lib.event_del(self.ev) < 0 :

    94

            raise Exception("event_del")

    95

    96

    97

    def activate (self, int fd, short mask) :

    98

        """

    99

            'Fake' this event as active, triggering the callback.

   100

        """

   101

   102

        lib.event_active(self.ev, fd, mask)

   103

   104

   106

        """

   107

            Returns a bool indicating if this event is pending (that is, has been .add()'d).

   108

   112

            XXX: support returning timeout value?

   113

        """

   114

   115

        return bool(lib.event_pending(self.ev, mask, NULL))

   116

   117

   118

    property fd :

   119

        def __get__ (self) :

   120

            """

   121

                Get the OS file descriptor associated with this event.

   122

            """

   123

   124

            return lib.event_get_fd(self.ev)

   125

   126

   127

    def __call__ (self, lib.evutil_socket_t fd, short mask) :

   128

        """

   129

            The method invoked by the internal libevent callback when the event becomes active.

   130

   131

                fd          - OS file descriptor the event occured on, or -1

   132

                mask        - bitmask of EV_* flags that represents the triggered event

   133

   134

   135

            The default implementation of __call__ does nothing. The method's return value will be ignored, and should

   136

            be None. Any errors raised by the callback will be printed out as warning messages, and ignored.

   137

        """

   138

   139

        pass

   140

   141

   142

    def __dealloc__ (self) :

   143

        """

   144

            Release the event object usign event_free. This should be completely safe as regards out event_base.

   145

   146

            XXX: what happens if event_base's __dealloc__ is triggered, but there are still event objects alive?

   147

        """

   151