rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/sched.py

@@ -0,0 +1,106 @@
+"""A generally useful event scheduler class.
+
+Each instance of this class manages its own queue.
+No multi-threading is implied; you are supposed to hack that
+yourself, or use a single instance per application.
+
+Each instance is parametrized with two functions, one that is
+supposed to return the current time, one that is supposed to
+implement a delay.  You can implement real-time scheduling by
+substituting time and sleep from built-in module time, or you can
+implement simulated time by writing your own functions.  This can
+also be used to integrate scheduling with STDWIN events; the delay
+function is allowed to modify the queue.  Time can be expressed as
+integers or floating point numbers, as long as it is consistent.
+
+Events are specified by tuples (time, priority, action, argument).
+As in UNIX, lower priority numbers mean higher priority; in this
+way the queue can be maintained fully sorted.  Execution of the
+event means calling the action function, passing it the argument.
+Remember that in Python, multiple function arguments can be packed
+in a tuple.   The action function may be an instance method so it
+has another way to reference private data (besides global variables).
+Parameterless functions or methods cannot be used, however.
+"""
+
+# XXX The timefunc and delayfunc should have been defined as methods
+# XXX so you can define new kinds of schedulers using subclassing
+# XXX instead of having to define a module or class just to hold
+# XXX the global state of your particular time and delay functions.
+
+import bisect
+
+__all__ = ["scheduler"]
+
+class scheduler:
+    def __init__(self, timefunc, delayfunc):
+        """Initialize a new instance, passing the time and delay
+        functions"""
+        self.queue = []
+        self.timefunc = timefunc
+        self.delayfunc = delayfunc
+
+    def enterabs(self, time, priority, action, argument):
+        """Enter a new event in the queue at an absolute time.
+
+        Returns an ID for the event which can be used to remove it,
+        if necessary.
+
+        """
+        event = time, priority, action, argument
+        bisect.insort(self.queue, event)
+        return event # The ID
+
+    def enter(self, delay, priority, action, argument):
+        """A variant that specifies the time as a relative time.
+
+        This is actually the more commonly used interface.
+
+        """
+        time = self.timefunc() + delay
+        return self.enterabs(time, priority, action, argument)
+
+    def cancel(self, event):
+        """Remove an event from the queue.
+
+        This must be presented the ID as returned by enter().
+        If the event is not in the queue, this raises RuntimeError.
+
+        """
+        self.queue.remove(event)
+
+    def empty(self):
+        """Check whether the queue is empty."""
+        return len(self.queue) == 0
+
+    def run(self):
+        """Execute events until the queue is empty.
+
+        When there is a positive delay until the first event, the
+        delay function is called and the event is left in the queue;
+        otherwise, the event is removed from the queue and executed
+        (its action function is called, passing it the argument).  If
+        the delay function returns prematurely, it is simply
+        restarted.
+
+        It is legal for both the delay function and the action
+        function to to modify the queue or to raise an exception;
+        exceptions are not caught but the scheduler's state remains
+        well-defined so run() may be called again.
+
+        A questionably hack is added to allow other threads to run:
+        just after an event is executed, a delay of 0 is executed, to
+        avoid monopolizing the CPU when other threads are also
+        runnable.
+
+        """
+        q = self.queue
+        while q:
+            time, priority, action, argument = q[0]
+            now = self.timefunc()
+            if now < time:
+                self.delayfunc(time - now)
+            else:
+                del q[0]
+                void = apply(action, argument)
+                self.delayfunc(0)   # Let other threads run

data/lib/rubyfox/server/data/lib/Lib/select.py

@@ -0,0 +1,211 @@
+"""
+AMAK: 20070515: New select implementation that uses java.nio
+"""
+
+import java.nio.channels.SelectableChannel
+import java.nio.channels.SelectionKey
+import java.nio.channels.Selector
+from java.nio.channels.SelectionKey import OP_ACCEPT, OP_CONNECT, OP_WRITE, OP_READ
+
+import socket
+
+import errno
+
+class error(Exception): pass
+
+ALL = None
+
+_exception_map = {
+
+# (<javaexception>, <circumstance>) : lambda: <code that raises the python equivalent>
+
+(java.nio.channels.IllegalBlockingModeException, ALL) : error(errno.ESOCKISBLOCKING, 'socket must be in non-blocking mode'),
+}
+
+def _map_exception(exc, circumstance=ALL):
+    try:
+        mapped_exception = _exception_map[(exc.__class__, circumstance)]
+        mapped_exception.java_exception = exc
+        return mapped_exception
+    except KeyError:
+        return error(-1, 'Unmapped java exception: <%s:%s>' % (exc.toString(), circumstance))
+
+POLLIN   = 1
+POLLOUT  = 2
+
+# The following event types are completely ignored on jython
+# Java does not support them, AFAICT
+# They are declared only to support code compatibility with cpython
+
+POLLPRI  = 4
+POLLERR  = 8
+POLLHUP  = 16
+POLLNVAL = 32
+
+def _getselectable(selectable_object):
+    for method in ['getchannel', 'fileno']:
+        try:
+            channel = getattr(selectable_object, method)()
+            if channel and not isinstance(channel, java.nio.channels.SelectableChannel):
+                raise TypeError("Object '%s' is not watchable" % selectable_object, errno.ENOTSOCK)
+            return channel
+        except:
+            pass
+    raise TypeError("Object '%s' is not watchable" % selectable_object, errno.ENOTSOCK)
+
+class poll:
+
+    def __init__(self):
+        self.selector = java.nio.channels.Selector.open()
+        self.chanmap = {}
+        self.unconnected_sockets = []
+
+    def _register_channel(self, socket_object, channel, mask):
+        jmask = 0
+        if mask & POLLIN:
+            # Note that OP_READ is NOT a valid event on server socket channels.
+            if channel.validOps() & OP_ACCEPT:
+                jmask = OP_ACCEPT
+            else:
+                jmask = OP_READ
+        if mask & POLLOUT:
+            jmask |= OP_WRITE
+            if channel.validOps() & OP_CONNECT:
+                jmask |= OP_CONNECT
+        selectionkey = channel.register(self.selector, jmask)
+        self.chanmap[channel] = (socket_object, selectionkey)
+
+    def _check_unconnected_sockets(self):
+        temp_list = []
+        for socket_object, mask in self.unconnected_sockets:
+            channel = _getselectable(socket_object)
+            if channel is not None:
+                self._register_channel(socket_object, channel, mask)
+            else:
+                temp_list.append( (socket_object, mask) )
+        self.unconnected_sockets = temp_list
+
+    def register(self, socket_object, mask = POLLIN|POLLOUT|POLLPRI):
+        try:
+            channel = _getselectable(socket_object)
+            if channel is None:
+                # The socket is not yet connected, and thus has no channel
+                # Add it to a pending list, and return
+                self.unconnected_sockets.append( (socket_object, mask) )
+                return
+            self._register_channel(socket_object, channel, mask)
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def unregister(self, socket_object):
+        try:
+            channel = _getselectable(socket_object)
+            self.chanmap[channel][1].cancel()
+            del self.chanmap[channel]
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def _dopoll(self, timeout):
+        if timeout is None or timeout < 0:
+            self.selector.select()
+        else:
+            try:
+                timeout = int(timeout)
+                if timeout == 0:
+                    self.selector.selectNow()
+                else:
+                    # No multiplication required: both cpython and java use millisecond timeouts
+                    self.selector.select(timeout)
+            except ValueError, vx:
+                raise error("poll timeout must be a number of milliseconds or None", errno.EINVAL)
+        # The returned selectedKeys cannot be used from multiple threads!
+        return self.selector.selectedKeys()
+
+    def poll(self, timeout=None):
+        try:
+            self._check_unconnected_sockets()
+            selectedkeys = self._dopoll(timeout)
+            results = []
+            for k in selectedkeys.iterator():
+                jmask = k.readyOps()
+                pymask = 0
+                if jmask & OP_READ: pymask |= POLLIN
+                if jmask & OP_WRITE: pymask |= POLLOUT
+                if jmask & OP_ACCEPT: pymask |= POLLIN
+                if jmask & OP_CONNECT: pymask |= POLLOUT
+                # Now return the original userobject, and the return event mask
+                results.append( (self.chanmap[k.channel()][0], pymask) )
+            return results
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+    def close(self):
+        try:
+            for k in self.selector.keys():
+                k.cancel()
+            self.selector.close()
+        except java.lang.Exception, jlx:
+            raise _map_exception(jlx)
+
+def _calcselecttimeoutvalue(value):
+    if value is None:
+        return None
+    try:
+        floatvalue = float(value)
+    except Exception, x:
+        raise TypeError("Select timeout value must be a number or None")
+    if value < 0:
+        raise error("Select timeout value cannot be negative", errno.EINVAL)
+    if floatvalue < 0.000001:
+        return 0
+    return int(floatvalue * 1000) # Convert to milliseconds
+
+def native_select(read_fd_list, write_fd_list, outofband_fd_list, timeout=None):
+    timeout = _calcselecttimeoutvalue(timeout)
+    # First create a poll object to do the actual watching.
+    pobj = poll()
+    try:
+        registered_for_read = {}
+        # Check the read list
+        for fd in read_fd_list:
+            pobj.register(fd, POLLIN)
+            registered_for_read[fd] = 1
+        # And now the write list
+        for fd in write_fd_list:
+            if registered_for_read.has_key(fd):
+            	# registering a second time overwrites the first
+                pobj.register(fd, POLLIN|POLLOUT)
+            else:
+                pobj.register(fd, POLLOUT)
+        results = pobj.poll(timeout)
+        # Now start preparing the results
+        read_ready_list, write_ready_list, oob_ready_list = [], [], []
+        for fd, mask in results:
+            if mask & POLLIN:
+                read_ready_list.append(fd)
+            if mask & POLLOUT:
+                write_ready_list.append(fd)
+        return read_ready_list, write_ready_list, oob_ready_list
+    finally:
+        # Need to close the poll object no matter what happened
+        # If it is left open, it may still have references to sockets
+        # That were registered before any exceptions occurred
+        pobj.close()
+
+select = native_select
+
+def cpython_compatible_select(read_fd_list, write_fd_list, outofband_fd_list, timeout=None):
+    # First turn all sockets to non-blocking
+    # keeping track of which ones have changed
+    modified_channels = []
+    try:
+        for socket_list in [read_fd_list, write_fd_list, outofband_fd_list]:
+            for s in socket_list:
+                channel = _getselectable(s)
+                if channel.isBlocking():
+                    modified_channels.append(channel)
+                    channel.configureBlocking(0)
+        return native_select(read_fd_list, write_fd_list, outofband_fd_list, timeout)
+    finally:
+        for channel in modified_channels:
+            channel.configureBlocking(1)

data/lib/rubyfox/server/data/lib/Lib/setsfactory.py

@@ -0,0 +1,10 @@
+from copy_reg import pickle, constructor
+from sets import Set as _Set, ImmutableSet as _ImmutableSet
+
+def Set(*args):
+  return _Set(*args)
+def ImmutableSet(*args):
+  return _ImmutableSet(*args)
+
+constructor(Set)
+constructor(ImmutableSet)