1

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

     2

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

     3

cimport qmsk.net.py as py

     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

    36

    # drop self-ref if not pending anymore (keep the local ref)

    37

    # XXX: does the event show up as non-pending here? :/

    38

    ev._unmark()

    39

    40

    # invoke

    41

    # XXX: logging?

    42

    ev(fd, mask)

    43

    44

    45

cdef class event :

    46

    47

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

    51

        # we don't hold a self-reference yet

    52

        self.alive = False

    53

    54

        # libevent seems to segfault otherwise...

    55

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

    56

            raise ValueError(fd)

    57

    58

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

    59

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

    60

    61

        if self.ev == NULL :

    62

            raise Exception("event_new")

    63

    64

    65

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

    66

        """

    67

            Re-assign our event parameters to the given ones.

    68

    69

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

    70

        """

    71

    72

        if self.alive :

    73

            raise RuntimeError("Cannot change event while active")

    74

    75

        # interesting... no error return code

    76

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

    77

    78

    79

    def add (self, timeout = None) :

    80

        """

    81

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

    82

    83

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

    84

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

    85

    86

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

    87

    88

                timeout     - a float representing the timeout length

    89

    90

            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

    91

        """

    92

    93

        cdef lib.timeval tv

    94

    95

        # aquire self-ref

    96

        self._mark()

    97

    98

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

    99

            raise Exception("event_new")

   100

   101

   102

    def delete (self) :

   103

        """

   104

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

   105

   106

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

   107

        """

   108

   109

   110

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

   111

            raise Exception("event_del")

   112

   113

        # release self-ref

   114

        self._unmark()

   115

   116

   117

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

   118

        """

   119

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

   120

        """

   121

   122

        # aquire self-ref

   123

        self._mark()

   124

   125

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

   126

   127

   128

    cpdef pending (self, short mask = 0xffff) :

   129

        """

   130

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

   131

   132

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

   133

            pending.

   134

   135

            XXX: support returning timeout value?

   136

        """

   137

   138

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

   139

   140

   141

    cdef object _mark (self) :

   142

        """

   143

            Refcount magic. Aquires an internal reference *if we don't have one yet*.

   144

        """

   145

   146

        if not self.alive :

   147

            self.alive = True

   148

   149

            py.Py_INCREF(self)

   150

   151

   152

    cdef object _unmark (self) :

   153

        """

   154

            Refcout magic. Releses the internal reference *if we have one* and libevent doesn't think this event is

   155

            pending anymore.

   156

   157

            XXX: this might cause ourselves to be destroyed... we can't break if that happens.

   158

        """

   159

   160

        if self.alive and not self.pending() :

   161

            py.Py_DECREF(self)

   162

   163

            self.alive = False

   164

   165

   166

    property fd :

   167

        def __get__ (self) :

   168

            """

   169

                Get the OS file descriptor associated with this event.

   170

            """

   171

   172

            return lib.event_get_fd(self.ev)

   173

   174

   175

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

   176

        """

   177

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

   178

   179

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

   180

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

   181

   182

   183

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

   184

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

   185

        """

   186

   187

        pass

   188

   189

   190

    def __dealloc__ (self) :

   191

        """

   192

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

   193

   194

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

   195

        """

   196

   197

        if self.ev != NULL :

   198

            lib.event_free(self.ev)

   199

   200

class CallbackEvent (event) :

   201

    """

   202

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

   203

   204

        This will pass the event object itself to the callback in place of the fd.

   205

    """

   206

   207

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

   208

        # parent

   209

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

   210

   211

        # store

   212

        self.callback = callback

   213

        self.args = args

   214

        self.kwargs = kwargs

   215

   216

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

   217

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

   218