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) :

    48

        # we don't hold a self-reference yet

    49

        self.alive = False

    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

    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

        """

    68

    69

        if self.alive :

    70

            raise RuntimeError("Cannot change event while active")

    71

    72

        # interesting... no error return code

    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

    92

        # aquire self-ref

    93

        self._mark()

    94

    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

   106

   107

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

   108

            raise Exception("event_del")

   109

   110

        # release self-ref

   111

        self._unmark()

   112

   113

   114

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

   115

        """

   116

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

   117

        """

   118

   119

        # aquire self-ref

   120

        self._mark()

   121

   122

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

   123

   124

   125

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

   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

   138

    cdef object _mark (self) :

   139

        """

   140

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

   141

        """

   142

   143

        if not self.alive :

   144

            self.alive = True

   145

   146

            py.Py_INCREF(self)

   147

   148

   149

    cdef object _unmark (self) :

   150

        """

   151

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

   152

            pending anymore.

   153

   154

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

   155

        """

   156

   157

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

   158

            py.Py_DECREF(self)

   159

   160

            self.alive = False

   161

   162

   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

        """

   189

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

   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.

   202

    """

   203

   204

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

   205

        # parent

   206

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

   207

   208

        # store

   209

        self.callback = callback

   210

        self.args = args

   211

        self.kwargs = kwargs

   212

   213

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

   215