1

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

     2

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

     4

     5

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

     6

    """

     7

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

     8

        NULL.

     9

    """

    10

    11

    cdef double t

    12

    13

    if timeout is not None :

    14

        t = timeout

    15

    16

        tv.tv_sec = <int>(t)

    17

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

    18

    19

        return tv

    20

    21

    else :

    22

        return NULL

    23

    24

    25

# our shared callback handler

    26

# this must aquire the GIL before invoking the python object

    27

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

    28

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

    29

    """

    30

        Proxy event back to event object passed as arg

    31

    """

    32

    33

    # unpack opaque arg

    34

    cdef event ev = <event>arg

    35

    40

    # invoke

    41

    # XXX: logging?

    42

    ev(fd, mask)

    44

    45

cdef class event :

    46

    47

    def __init__ (self, event_base base not None, lib.evutil_socket_t fd, short events) :

    50

    51

        # libevent seems to segfault otherwise...

    52

        if events & (lib.EV_READ | lib.EV_WRITE) and fd < 0 :

    53

            raise ValueError(fd)

    54

    55

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

    56

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

    57

    58

        if self.ev == NULL :

    59

            raise Exception("event_new")

    60

    61

    62

    def assign (self, event_base base not None, lib.evutil_socket_t fd, short events) :

    63

        """

    64

            Re-assign our event parameters to the given ones.

    65

    66

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

    67

        """

    71

    72

        # interesting... no error return code

    73

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

    74

    75

    76

    def add (self, timeout = None) :

    77

        """

    78

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

    79

    80

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

    81

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

    82

    83

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

    84

    85

                timeout     - a float representing the timeout length

    86

    87

            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

    88

        """

    89

    90

        cdef lib.timeval tv

    91

    95

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

    96

            raise Exception("event_new")

    97

    98

    99

    def delete (self) :

   100

        """

   101

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

   102

   103

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

   104

        """

   105

   107

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

   108

            raise Exception("event_del")

   109

   113

   114

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

   115

        """

   116

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

   117

        """

   121

   122

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

   123

   124

   126

        """

   127

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

   128

   129

            For convenience, this defaults to testing all possible flags, and so will return true if any events are

   130

            pending.

   131

   132

            XXX: support returning timeout value?

   133

        """

   134

   135

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

   136

   137

   163

    property fd :

   164

        def __get__ (self) :

   165

            """

   166

                Get the OS file descriptor associated with this event.

   167

            """

   168

   169

            return lib.event_get_fd(self.ev)

   170

   171

   172

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

   173

        """

   174

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

   175

   176

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

   177

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

   178

   179

   180

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

   181

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

   182

        """

   183

   184

        pass

   185

   186

   187

    def __dealloc__ (self) :

   188

        """

   190

   191

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

   192

        """

   193

   194

        if self.ev != NULL :

   195

            lib.event_free(self.ev)

   196

   197

class CallbackEvent (event) :

   198

    """

   199

        Extends the event type to take a callback and additional arguments to invoke from the __call__ method.

   200

    """

   201

   202

    def __init__ (self, event_base base, lib.evutil_socket_t fd, short events, object callback, *args, **kwargs) :

   203

        # parent

   204

        super(CallbackEvent, self).__init__(base, fd, events)

   205

   206

        # store

   207

        self.callback = callback

   208

        self.args = args

   209

        self.kwargs = kwargs

   210

   211

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

   212

        self.callback(fd, mask, *self.args, **self.kwargs)

   213